Initial commit
This commit is contained in:
LZH-YS1998
@@ -0,0 +1,998 @@
|
||||
"""Employee experience tracking, project reflections, and learned-skill distillation."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
import json
|
||||
import hashlib
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from opc.core.config import validate_organization_id
|
||||
from opc.core.models import TaskStatus
|
||||
from opc.layer2_organization.work_item_identity import projection_id_for_task
|
||||
from opc.layer5_memory.preference import PreferenceManager
|
||||
from opc.layer5_memory.skill_library import Skill, SkillLibrary
|
||||
|
||||
|
||||
def _utc_now() -> str:
|
||||
return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
|
||||
|
||||
|
||||
class EmployeeEvolutionManager:
|
||||
"""Tracks employee outcomes, project reflections, and learned skills."""
|
||||
|
||||
LEARNED_SKILL_THRESHOLD = 2
|
||||
EMPLOYEE_EXPERIENCE_SCHEMA_VERSION = 1
|
||||
|
||||
def __init__(self, opc_home) -> None:
|
||||
self.opc_home = Path(opc_home)
|
||||
self.preferences = PreferenceManager(self.opc_home)
|
||||
self.skills = SkillLibrary(self.opc_home)
|
||||
self.skills.load_all()
|
||||
|
||||
def evolution_profile_path(self, project_id: str | None = None) -> Path:
|
||||
"""Return the structured company-evolution state path.
|
||||
|
||||
Employee evolution is runtime/company state, not user/project durable
|
||||
memory. Keeping it outside ``memory/*.md`` lets company mode retain
|
||||
experience scoring and learned playbooks without reintroducing hidden
|
||||
user preference writes.
|
||||
"""
|
||||
project = str(project_id or "").strip()
|
||||
if project:
|
||||
return self.opc_home / "projects" / project / "employee_evolution.json"
|
||||
return self.opc_home / "evolution" / "employees.json"
|
||||
|
||||
def load_evolution_profile(self, project_id: str | None = None) -> dict[str, Any]:
|
||||
path = self.evolution_profile_path(project_id)
|
||||
if not path.exists():
|
||||
return {}
|
||||
try:
|
||||
data = json.loads(path.read_text(encoding="utf-8"))
|
||||
return data if isinstance(data, dict) else {}
|
||||
except Exception:
|
||||
return {}
|
||||
|
||||
def save_evolution_profile(self, profile: dict[str, Any], project_id: str | None = None) -> None:
|
||||
path = self.evolution_profile_path(project_id)
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text(
|
||||
json.dumps(dict(profile or {}), ensure_ascii=False, indent=2, sort_keys=True) + "\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
|
||||
def employee_experience_dir(self, organization_id: str) -> Path:
|
||||
org_id = validate_organization_id(organization_id)
|
||||
return self.opc_home / "company_state" / org_id / "employee_experience"
|
||||
|
||||
def employee_experience_path(self, organization_id: str, employee_id: str) -> Path:
|
||||
safe_id = self._safe_employee_filename(employee_id)
|
||||
return self.employee_experience_dir(organization_id) / f"{safe_id}.json"
|
||||
|
||||
def load_employee_experience(self, organization_id: str, employee_id: str) -> dict[str, Any]:
|
||||
path = self.employee_experience_path(organization_id, employee_id)
|
||||
if not path.exists():
|
||||
return {}
|
||||
try:
|
||||
data = json.loads(path.read_text(encoding="utf-8"))
|
||||
return data if isinstance(data, dict) else {}
|
||||
except Exception:
|
||||
return {}
|
||||
|
||||
def save_employee_experience(self, organization_id: str, employee_id: str, profile: dict[str, Any]) -> None:
|
||||
path = self.employee_experience_path(organization_id, employee_id)
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text(
|
||||
json.dumps(dict(profile or {}), ensure_ascii=False, indent=2, sort_keys=True) + "\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
|
||||
def get_employee_profile(self, employee_id: str, project_id: str | None = None) -> dict[str, Any]:
|
||||
global_profile = self.load_evolution_profile()
|
||||
project_profile = self.load_evolution_profile(project_id) if project_id else {}
|
||||
global_data = dict(global_profile.get("employees", {}).get(employee_id, {}))
|
||||
project_data = dict(project_profile.get("employees", {}).get(employee_id, {}))
|
||||
return self._deep_merge(global_data, project_data)
|
||||
|
||||
def get_learned_skill_refs(self, employee_id: str, project_id: str | None = None) -> list[str]:
|
||||
profile = self.get_employee_profile(employee_id, project_id)
|
||||
refs = list(profile.get("learned_skill_refs", []))
|
||||
unique: list[str] = []
|
||||
for ref in refs:
|
||||
if ref and ref not in unique:
|
||||
unique.append(ref)
|
||||
return unique
|
||||
|
||||
def build_employee_delta_context(
|
||||
self,
|
||||
employee_id: str,
|
||||
project_id: str | None = None,
|
||||
organization_id: str | None = None,
|
||||
) -> str:
|
||||
profile = self.get_employee_profile(employee_id, project_id)
|
||||
delta = dict(profile.get("delta_profile", {}))
|
||||
experience_profile: dict[str, Any] = {}
|
||||
experience_delta: dict[str, Any] = {}
|
||||
if organization_id:
|
||||
experience_profile = self.load_employee_experience(organization_id, employee_id)
|
||||
experience_delta = dict(experience_profile.get("delta_profile", {}) or {})
|
||||
if not delta and not experience_delta:
|
||||
return ""
|
||||
|
||||
parts: list[str] = []
|
||||
evolution_count = int(experience_profile.get("evolution_count", 0) or len(experience_profile.get("events", []) or []))
|
||||
if evolution_count:
|
||||
parts.append(f"Self-evolution reviews: {evolution_count}")
|
||||
projects_reflected = int(profile.get("projects_reflected", 0))
|
||||
if projects_reflected:
|
||||
parts.append(f"Reflected projects: {projects_reflected}")
|
||||
|
||||
for title, key in (
|
||||
("Self-Evolved Strengths", "strengths"),
|
||||
("Self-Evolved Adjustments", "adjustments"),
|
||||
("Self-Evolved Watchouts", "avoid_next_time"),
|
||||
("Self-Evolved Routing Notes", "routing_notes"),
|
||||
):
|
||||
values = [str(item).strip() for item in list(experience_delta.get(key, []) or []) if str(item).strip()]
|
||||
if values:
|
||||
parts.append(f"## {title}\n" + "\n".join(f"- {item}" for item in values[:6]))
|
||||
|
||||
for title, key in (
|
||||
("Working Patterns", "working_patterns"),
|
||||
("Default Checklists", "default_checklists"),
|
||||
("Reviewer Preferences", "reviewer_preferences"),
|
||||
("Risk Watchouts", "risk_watchouts"),
|
||||
("Tool Preferences", "tool_preferences"),
|
||||
("Fit Domains", "fit_domains"),
|
||||
("Avoid Domains", "avoid_domains"),
|
||||
):
|
||||
values = [str(item).strip() for item in delta.get(key, []) if str(item).strip()]
|
||||
if values:
|
||||
parts.append(f"## {title}\n" + "\n".join(f"- {item}" for item in values[:6]))
|
||||
|
||||
return "\n\n".join(parts)
|
||||
|
||||
def get_experience_score(
|
||||
self,
|
||||
employee_id: str,
|
||||
role_id: str,
|
||||
domains: list[str] | None = None,
|
||||
project_id: str | None = None,
|
||||
organization_id: str | None = None,
|
||||
) -> float:
|
||||
profile = self.get_employee_profile(employee_id, project_id)
|
||||
total_successes = int(profile.get("successes", 0))
|
||||
total_partials = int(profile.get("partial_successes", 0))
|
||||
total_failures = int(profile.get("failures", 0))
|
||||
role_successes = int(profile.get("roles", {}).get(role_id, {}).get("successes", 0))
|
||||
role_partials = int(profile.get("roles", {}).get(role_id, {}).get("partial_successes", 0))
|
||||
role_failures = int(profile.get("roles", {}).get(role_id, {}).get("failures", 0))
|
||||
learned_bonus = 2 * len(profile.get("learned_skill_refs", []))
|
||||
reflection_bonus = min(4, int(profile.get("projects_reflected", 0)))
|
||||
domain_bonus = 0
|
||||
for domain in domains or []:
|
||||
domain_record = profile.get("domains", {}).get(domain, {})
|
||||
domain_bonus += int(domain_record.get("successes", 0))
|
||||
domain_bonus += 0.5 * int(domain_record.get("partial_successes", 0))
|
||||
domain_bonus -= 0.25 * int(domain_record.get("failures", 0))
|
||||
score = (
|
||||
total_successes
|
||||
+ (0.5 * total_partials)
|
||||
- (0.25 * total_failures)
|
||||
+ (2 * role_successes)
|
||||
+ role_partials
|
||||
- (0.5 * role_failures)
|
||||
+ domain_bonus
|
||||
+ learned_bonus
|
||||
+ reflection_bonus
|
||||
)
|
||||
if organization_id:
|
||||
experience_profile = self.load_employee_experience(organization_id, employee_id)
|
||||
events = [item for item in list(experience_profile.get("events", []) or []) if isinstance(item, dict)]
|
||||
score += min(8.0, float(len(events)))
|
||||
for event in events[-8:]:
|
||||
if str(event.get("role_id", "") or "").strip() == role_id:
|
||||
score += 0.5
|
||||
return float(max(0.0, score))
|
||||
|
||||
def apply_employee_evolution_patch(
|
||||
self,
|
||||
*,
|
||||
organization_id: str,
|
||||
patch: dict[str, Any],
|
||||
source: dict[str, Any] | None = None,
|
||||
allowed_employee_ids: set[str] | None = None,
|
||||
) -> list[dict[str, Any]]:
|
||||
org_id = validate_organization_id(organization_id)
|
||||
source_payload = dict(source or {})
|
||||
raw_events = list(patch.get("patches", []) or [])
|
||||
allowed = {str(item).strip() for item in (allowed_employee_ids or set()) if str(item).strip()}
|
||||
recorded: list[dict[str, Any]] = []
|
||||
|
||||
for raw_event in raw_events:
|
||||
if not isinstance(raw_event, dict):
|
||||
continue
|
||||
employee_id = str(raw_event.get("employee_id", "") or "").strip()
|
||||
if not employee_id or (allowed and employee_id not in allowed):
|
||||
continue
|
||||
event = self._normalize_self_evolution_event(raw_event, source_payload)
|
||||
if not event:
|
||||
continue
|
||||
|
||||
profile = self.load_employee_experience(org_id, employee_id)
|
||||
if not profile:
|
||||
profile = {
|
||||
"schema_version": self.EMPLOYEE_EXPERIENCE_SCHEMA_VERSION,
|
||||
"kind": "company_employee_experience",
|
||||
"organization_id": org_id,
|
||||
"employee_id": employee_id,
|
||||
"events": [],
|
||||
"delta_profile": {},
|
||||
"evolution_count": 0,
|
||||
}
|
||||
profile["schema_version"] = self.EMPLOYEE_EXPERIENCE_SCHEMA_VERSION
|
||||
profile["kind"] = "company_employee_experience"
|
||||
profile["organization_id"] = org_id
|
||||
profile["employee_id"] = employee_id
|
||||
events = [item for item in list(profile.get("events", []) or []) if isinstance(item, dict)]
|
||||
event_id = str(event.get("event_id", "") or "").strip()
|
||||
if event_id and any(str(item.get("event_id", "") or "").strip() == event_id for item in events):
|
||||
continue
|
||||
events.append(event)
|
||||
profile["events"] = events[-100:]
|
||||
profile["evolution_count"] = int(profile.get("evolution_count", 0) or 0) + 1
|
||||
profile["updated_at"] = _utc_now()
|
||||
profile["delta_profile"] = self._build_self_evolution_delta(profile["events"])
|
||||
self.save_employee_experience(org_id, employee_id, profile)
|
||||
recorded.append({
|
||||
"employee_id": employee_id,
|
||||
"event_id": event_id,
|
||||
"status": "recorded",
|
||||
"path": str(self.employee_experience_path(org_id, employee_id)),
|
||||
})
|
||||
|
||||
return recorded
|
||||
|
||||
def record_work_item_completion(
|
||||
self,
|
||||
task: Any,
|
||||
result_content: str,
|
||||
*,
|
||||
outcome: str = "success",
|
||||
feedback_summary: str = "",
|
||||
strengths: list[str] | None = None,
|
||||
weaknesses: list[str] | None = None,
|
||||
rationale: str = "",
|
||||
) -> dict[str, Any]:
|
||||
assignment = dict(getattr(task, "metadata", {}).get("employee_assignment", {}) or {})
|
||||
employee_id = str(assignment.get("employee_id", "")).strip()
|
||||
if not employee_id:
|
||||
return {}
|
||||
|
||||
role_id = str(
|
||||
assignment.get("role_id")
|
||||
or getattr(task, "assigned_to", "")
|
||||
or getattr(task, "metadata", {}).get("work_item_role_id", "")
|
||||
).strip()
|
||||
domains = list(assignment.get("domains") or getattr(task, "tags", []) or [])
|
||||
project_id = getattr(task, "project_id", None) or None
|
||||
summary = str(getattr(task, "metadata", {}).get("work_item_summary_for_downstream", "") or result_content).strip()
|
||||
pattern_key = self._pattern_key(role_id, domains)
|
||||
normalized_outcome = self._normalize_outcome(outcome)
|
||||
base_payload = {
|
||||
"employee_id": employee_id,
|
||||
"employee_name": assignment.get("name", ""),
|
||||
"role_id": role_id,
|
||||
"template_id": assignment.get("template_id", ""),
|
||||
"category": assignment.get("category", ""),
|
||||
}
|
||||
|
||||
global_profile = self.load_evolution_profile()
|
||||
self._record_in_profile(
|
||||
global_profile,
|
||||
base_payload=base_payload,
|
||||
role_id=role_id,
|
||||
domains=domains,
|
||||
pattern_key=pattern_key,
|
||||
summary=summary,
|
||||
outcome=normalized_outcome,
|
||||
feedback_summary=feedback_summary,
|
||||
strengths=list(strengths or []),
|
||||
weaknesses=list(weaknesses or []),
|
||||
rationale=rationale,
|
||||
)
|
||||
self.save_evolution_profile(global_profile)
|
||||
|
||||
if project_id:
|
||||
project_profile = self.load_evolution_profile(project_id)
|
||||
self._record_in_profile(
|
||||
project_profile,
|
||||
base_payload=base_payload,
|
||||
role_id=role_id,
|
||||
domains=domains,
|
||||
pattern_key=pattern_key,
|
||||
summary=summary,
|
||||
outcome=normalized_outcome,
|
||||
feedback_summary=feedback_summary,
|
||||
strengths=list(strengths or []),
|
||||
weaknesses=list(weaknesses or []),
|
||||
rationale=rationale,
|
||||
)
|
||||
self.save_evolution_profile(project_profile, project_id)
|
||||
|
||||
return {
|
||||
"employee_id": employee_id,
|
||||
"project_id": project_id or "",
|
||||
"pattern_key": pattern_key,
|
||||
"outcome": normalized_outcome,
|
||||
}
|
||||
|
||||
def record_project_reflections(
|
||||
self,
|
||||
delivery_task: Any,
|
||||
work_item_tasks: list[Any],
|
||||
partial: bool = False,
|
||||
*,
|
||||
feedback: dict[str, Any] | None = None,
|
||||
evaluation: dict[str, Any] | None = None,
|
||||
) -> list[dict[str, Any]]:
|
||||
project_id = str(getattr(delivery_task, "project_id", "") or "").strip()
|
||||
delivery_task_id = str(getattr(delivery_task, "id", "") or "").strip()
|
||||
if not project_id or not delivery_task_id:
|
||||
return []
|
||||
|
||||
tasks = self._normalize_work_item_tasks(work_item_tasks, delivery_task)
|
||||
terminal = {TaskStatus.DONE, TaskStatus.FAILED, TaskStatus.CANCELLED}
|
||||
employee_groups: dict[str, list[Any]] = {}
|
||||
for task in tasks:
|
||||
if getattr(task, "status", None) not in terminal:
|
||||
continue
|
||||
assignment = dict(getattr(task, "metadata", {}).get("employee_assignment", {}) or {})
|
||||
employee_id = str(assignment.get("employee_id", "")).strip()
|
||||
if not employee_id:
|
||||
continue
|
||||
employee_groups.setdefault(employee_id, []).append(task)
|
||||
|
||||
results: list[dict[str, Any]] = []
|
||||
for employee_id, employee_tasks in employee_groups.items():
|
||||
reflection = self._build_project_reflection(
|
||||
delivery_task=delivery_task,
|
||||
employee_tasks=employee_tasks,
|
||||
project_id=project_id,
|
||||
partial=partial,
|
||||
feedback=feedback,
|
||||
evaluation=evaluation,
|
||||
)
|
||||
reflection_path = self.evolution_profile_path(project_id)
|
||||
|
||||
global_profile = self.load_evolution_profile()
|
||||
self._record_project_reflection_in_profile(
|
||||
global_profile,
|
||||
reflection=reflection,
|
||||
reflection_path=reflection_path,
|
||||
)
|
||||
learned_skill_ref = self._maybe_promote_reflection_skill(global_profile, reflection, project_id=project_id)
|
||||
self.save_evolution_profile(global_profile)
|
||||
|
||||
project_profile = self.load_evolution_profile(project_id)
|
||||
self._record_project_reflection_in_profile(
|
||||
project_profile,
|
||||
reflection=reflection,
|
||||
reflection_path=reflection_path,
|
||||
)
|
||||
if learned_skill_ref:
|
||||
self._attach_learned_skill(
|
||||
project_profile,
|
||||
reflection["employee_id"],
|
||||
reflection["pattern_key"],
|
||||
learned_skill_ref,
|
||||
)
|
||||
else:
|
||||
learned_skill_ref = self._maybe_promote_reflection_skill(project_profile, reflection, project_id=project_id)
|
||||
self.save_evolution_profile(project_profile, project_id)
|
||||
|
||||
results.append({
|
||||
"employee_id": employee_id,
|
||||
"reflection_path": str(reflection_path),
|
||||
"learned_skill_ref": learned_skill_ref,
|
||||
"status": "recorded",
|
||||
"reflection": reflection,
|
||||
})
|
||||
|
||||
return results
|
||||
|
||||
def _record_in_profile(
|
||||
self,
|
||||
profile: dict[str, Any],
|
||||
*,
|
||||
base_payload: dict[str, Any],
|
||||
role_id: str,
|
||||
domains: list[str],
|
||||
pattern_key: str,
|
||||
summary: str,
|
||||
outcome: str,
|
||||
feedback_summary: str,
|
||||
strengths: list[str],
|
||||
weaknesses: list[str],
|
||||
rationale: str,
|
||||
) -> None:
|
||||
employees = profile.setdefault("employees", {})
|
||||
record = employees.setdefault(base_payload["employee_id"], {})
|
||||
record.update({
|
||||
"employee_name": base_payload.get("employee_name", ""),
|
||||
"role_id": role_id,
|
||||
"template_id": base_payload.get("template_id", ""),
|
||||
"category": base_payload.get("category", ""),
|
||||
"updated_at": _utc_now(),
|
||||
})
|
||||
self._increment_outcome_counts(record, outcome)
|
||||
record["last_outcome"] = outcome
|
||||
if feedback_summary:
|
||||
record["last_feedback_summary"] = feedback_summary
|
||||
if rationale:
|
||||
record["last_feedback_rationale"] = rationale
|
||||
roles = record.setdefault("roles", {})
|
||||
role_record = roles.setdefault(role_id, {"successes": 0, "partial_successes": 0, "failures": 0})
|
||||
self._increment_outcome_counts(role_record, outcome)
|
||||
role_record["last_outcome"] = outcome
|
||||
domain_records = record.setdefault("domains", {})
|
||||
for domain in domains:
|
||||
domain_record = domain_records.setdefault(domain, {"successes": 0, "partial_successes": 0, "failures": 0})
|
||||
self._increment_outcome_counts(domain_record, outcome)
|
||||
domain_record["last_outcome"] = outcome
|
||||
patterns = record.setdefault("patterns", {})
|
||||
pattern = patterns.setdefault(pattern_key, self._base_pattern_record(role_id, domains))
|
||||
self._increment_outcome_counts(pattern, outcome)
|
||||
pattern["last_summary"] = summary
|
||||
pattern["last_outcome"] = outcome
|
||||
pattern["last_feedback_summary"] = feedback_summary
|
||||
pattern["last_feedback_rationale"] = rationale
|
||||
if outcome == "success":
|
||||
pattern["last_success_at"] = _utc_now()
|
||||
elif outcome == "partial_success":
|
||||
pattern["last_partial_success_at"] = _utc_now()
|
||||
else:
|
||||
pattern["last_failure_at"] = _utc_now()
|
||||
self._increment_counts(record, "working_pattern_counts", strengths)
|
||||
self._increment_counts(record, "risk_watchout_counts", weaknesses)
|
||||
self._increment_counts(pattern, "working_pattern_counts", strengths)
|
||||
self._increment_counts(pattern, "risk_watchout_counts", weaknesses)
|
||||
record["delta_profile"] = self._build_delta_profile(record)
|
||||
record.setdefault("learned_skill_refs", [])
|
||||
|
||||
def _record_project_reflection_in_profile(
|
||||
self,
|
||||
profile: dict[str, Any],
|
||||
*,
|
||||
reflection: dict[str, Any],
|
||||
reflection_path: Path,
|
||||
) -> None:
|
||||
employees = profile.setdefault("employees", {})
|
||||
employee_id = str(reflection.get("employee_id", "")).strip()
|
||||
if not employee_id:
|
||||
return
|
||||
record = employees.setdefault(employee_id, {})
|
||||
record.update({
|
||||
"employee_name": reflection.get("employee_name", ""),
|
||||
"role_id": reflection.get("role_id", ""),
|
||||
"template_id": reflection.get("template_id", ""),
|
||||
"category": reflection.get("category", ""),
|
||||
"updated_at": _utc_now(),
|
||||
"last_reflection_at": _utc_now(),
|
||||
})
|
||||
reflection_ids = record.setdefault("project_reflection_ids", [])
|
||||
if reflection["delivery_task_id"] in reflection_ids:
|
||||
return
|
||||
reflection_ids.append(reflection["delivery_task_id"])
|
||||
reflection_paths = record.setdefault("reflection_paths", [])
|
||||
reflection_paths.append(str(reflection_path))
|
||||
project_ids = record.setdefault("project_ids", [])
|
||||
if reflection["project_id"] not in project_ids:
|
||||
project_ids.append(reflection["project_id"])
|
||||
record["projects_reflected"] = len(project_ids)
|
||||
|
||||
patterns = record.setdefault("patterns", {})
|
||||
pattern_key = str(reflection.get("pattern_key", ""))
|
||||
pattern = patterns.setdefault(
|
||||
pattern_key,
|
||||
self._base_pattern_record(
|
||||
str(reflection.get("role_id", "")).strip(),
|
||||
list(reflection.get("domains", [])),
|
||||
),
|
||||
)
|
||||
pattern["role_id"] = reflection.get("role_id", "")
|
||||
pattern["domains"] = list(reflection.get("domains", []))
|
||||
pattern["reflection_count"] = int(pattern.get("reflection_count", 0)) + 1
|
||||
pattern["latest_project_summary"] = str(reflection.get("project_summary", ""))
|
||||
pattern["last_reflection_at"] = _utc_now()
|
||||
project_reflection_paths = pattern.setdefault("reflection_paths", [])
|
||||
project_reflection_paths.append(str(reflection_path))
|
||||
|
||||
self._increment_counts(pattern, "working_pattern_counts", reflection.get("what_worked", []))
|
||||
self._increment_counts(pattern, "checklist_counts", reflection.get("reusable_checklist", []))
|
||||
self._increment_counts(pattern, "reviewer_preference_counts", reflection.get("reviewer_preferences", []))
|
||||
self._increment_counts(pattern, "tool_preference_counts", reflection.get("tool_preferences", []))
|
||||
self._increment_counts(pattern, "risk_watchout_counts", reflection.get("mistakes_to_avoid", []))
|
||||
self._increment_counts(pattern, "fit_domain_counts", reflection.get("suitable_for", []))
|
||||
self._increment_counts(pattern, "avoid_domain_counts", reflection.get("avoid_for", []))
|
||||
|
||||
self._increment_counts(record, "working_pattern_counts", reflection.get("what_worked", []))
|
||||
self._increment_counts(record, "checklist_counts", reflection.get("reusable_checklist", []))
|
||||
self._increment_counts(record, "reviewer_preference_counts", reflection.get("reviewer_preferences", []))
|
||||
self._increment_counts(record, "tool_preference_counts", reflection.get("tool_preferences", []))
|
||||
self._increment_counts(record, "risk_watchout_counts", reflection.get("mistakes_to_avoid", []))
|
||||
self._increment_counts(record, "fit_domain_counts", reflection.get("suitable_for", []))
|
||||
self._increment_counts(record, "avoid_domain_counts", reflection.get("avoid_for", []))
|
||||
record["delta_profile"] = self._build_delta_profile(record)
|
||||
record.setdefault("learned_skill_refs", [])
|
||||
|
||||
def _build_project_reflection(
|
||||
self,
|
||||
*,
|
||||
delivery_task: Any,
|
||||
employee_tasks: list[Any],
|
||||
project_id: str,
|
||||
partial: bool = False,
|
||||
feedback: dict[str, Any] | None = None,
|
||||
evaluation: dict[str, Any] | None = None,
|
||||
) -> dict[str, Any]:
|
||||
first_assignment = dict(employee_tasks[0].metadata.get("employee_assignment", {}) or {})
|
||||
employee_id = str(first_assignment.get("employee_id", "")).strip()
|
||||
role_id = str(first_assignment.get("role_id") or getattr(employee_tasks[0], "assigned_to", "") or "").strip()
|
||||
domains = self._collect_domains(employee_tasks, fallback=list(first_assignment.get("domains", [])))
|
||||
pattern_key = self._pattern_key(role_id, domains)
|
||||
task_summaries = self._collect_task_summaries(employee_tasks)
|
||||
artifacts = self._collect_items(employee_tasks, "artifacts")
|
||||
decisions = self._collect_items(employee_tasks, "decisions")
|
||||
risks = self._collect_items(employee_tasks, "risks")
|
||||
open_questions = self._collect_items(employee_tasks, "open_questions")
|
||||
preferred_agents = self._collect_preferred_agents(employee_tasks, first_assignment)
|
||||
employee_feedback = self._find_employee_feedback(employee_id, evaluation)
|
||||
historical_context = self.build_employee_delta_context(employee_id, project_id=project_id)
|
||||
feedback_summary = str((evaluation or {}).get("summary", "") or (feedback or {}).get("raw_feedback", "")).strip()
|
||||
|
||||
what_worked = [
|
||||
"Break work into explicit deliverables and leave concise handoff summaries.",
|
||||
"Preserve reviewer-friendly artifacts so downstream validation is faster.",
|
||||
]
|
||||
if decisions:
|
||||
what_worked.append("Capture explicit implementation decisions that downstream reviewers can verify.")
|
||||
if artifacts:
|
||||
what_worked.append("Reference exact artifact paths or outputs in every handoff.")
|
||||
|
||||
reusable_checklist = [
|
||||
"State the objective and completion summary explicitly in the handoff.",
|
||||
"Leave reviewer-friendly artifacts for the next work item.",
|
||||
]
|
||||
if decisions:
|
||||
reusable_checklist.append("Record key decisions that affect downstream execution.")
|
||||
if artifacts:
|
||||
reusable_checklist.append("List concrete artifact references for changed outputs.")
|
||||
if any(domain in {"coding", "api", "backend", "frontend", "devops"} for domain in domains):
|
||||
reusable_checklist.append("Include validation or test evidence before requesting review.")
|
||||
|
||||
reviewer_preferences = [
|
||||
"Make decisions, risks, and artifact references explicit for review.",
|
||||
]
|
||||
if risks or open_questions:
|
||||
reviewer_preferences.append("Flag unresolved risks and open questions before requesting approval.")
|
||||
if artifacts:
|
||||
reviewer_preferences.append("Point reviewers to exact changed files or deliverables.")
|
||||
|
||||
tool_preferences = [
|
||||
f"Prefer external agent `{agent}` for similar `{role_id}` work."
|
||||
for agent in preferred_agents
|
||||
]
|
||||
|
||||
mistakes_to_avoid = list(risks[:4])
|
||||
if open_questions:
|
||||
mistakes_to_avoid.extend(item for item in open_questions[:2] if item not in mistakes_to_avoid)
|
||||
if not mistakes_to_avoid:
|
||||
mistakes_to_avoid.append("Avoid handoffs that omit concrete artifacts, risks, or validation notes.")
|
||||
what_worked.extend(str(item).strip() for item in list(employee_feedback.get("strengths", [])) if str(item).strip())
|
||||
mistakes_to_avoid.extend(str(item).strip() for item in list(employee_feedback.get("weaknesses", [])) if str(item).strip())
|
||||
if feedback_summary:
|
||||
reviewer_preferences.append(f"Carry forward user feedback themes: {feedback_summary}")
|
||||
|
||||
suitable_for = list(domains or [role_id])
|
||||
avoid_for = self._infer_avoid_domains(mistakes_to_avoid)
|
||||
confidence = round(min(0.95, 0.55 + (0.08 * len(employee_tasks))), 2)
|
||||
|
||||
failed_tasks = [
|
||||
t for t in employee_tasks
|
||||
if getattr(t, "status", None) != TaskStatus.DONE
|
||||
]
|
||||
failures: list[dict[str, str]] = []
|
||||
if failed_tasks:
|
||||
for t in failed_tasks:
|
||||
reason = str(getattr(t, "metadata", {}).get("failure_reason", ""))
|
||||
failures.append({
|
||||
"task": getattr(t, "title", ""),
|
||||
"status": str(getattr(t, "status", "")),
|
||||
"reason": reason,
|
||||
})
|
||||
if reason:
|
||||
mistakes_to_avoid.append(reason)
|
||||
|
||||
if partial:
|
||||
confidence = round(min(confidence, 0.4), 2)
|
||||
|
||||
result: dict[str, Any] = {
|
||||
"employee_id": employee_id,
|
||||
"employee_name": first_assignment.get("name", ""),
|
||||
"template_id": first_assignment.get("template_id", ""),
|
||||
"category": first_assignment.get("category", ""),
|
||||
"project_id": project_id,
|
||||
"delivery_task_id": str(getattr(delivery_task, "id", "") or ""),
|
||||
"delivery_projection_id": projection_id_for_task(delivery_task),
|
||||
"role_id": role_id,
|
||||
"domains": domains,
|
||||
"pattern_key": pattern_key,
|
||||
"project_summary": " ".join(task_summaries[:3]),
|
||||
"what_worked": self._dedupe_preserve_order(what_worked),
|
||||
"mistakes_to_avoid": self._dedupe_preserve_order(mistakes_to_avoid),
|
||||
"reusable_checklist": self._dedupe_preserve_order(reusable_checklist),
|
||||
"reviewer_preferences": self._dedupe_preserve_order(reviewer_preferences),
|
||||
"tool_preferences": self._dedupe_preserve_order(tool_preferences),
|
||||
"suitable_for": self._dedupe_preserve_order(suitable_for),
|
||||
"avoid_for": self._dedupe_preserve_order(avoid_for),
|
||||
"confidence": confidence,
|
||||
"source_task_ids": [str(getattr(task, "id", "")) for task in employee_tasks],
|
||||
"created_at": _utc_now(),
|
||||
"employee_outcome": self._normalize_outcome(str(employee_feedback.get("outcome", "partial_success") or "partial_success")),
|
||||
"feedback_summary": feedback_summary,
|
||||
"feedback_rationale": str(employee_feedback.get("reason", "")).strip(),
|
||||
}
|
||||
if historical_context:
|
||||
result["historical_context"] = historical_context
|
||||
if feedback:
|
||||
result["user_feedback"] = {
|
||||
"label": str(feedback.get("label", "")).strip(),
|
||||
"raw_feedback": str(feedback.get("raw_feedback", "")).strip(),
|
||||
"scope": str(feedback.get("scope", "")).strip(),
|
||||
}
|
||||
if evaluation:
|
||||
result["runtime_feedback_evaluation"] = {
|
||||
"overall_outcome": str(evaluation.get("overall_outcome", "")).strip(),
|
||||
"summary": str(evaluation.get("summary", "")).strip(),
|
||||
"strengths": [str(item).strip() for item in list(evaluation.get("strengths", [])) if str(item).strip()][:6],
|
||||
"weaknesses": [str(item).strip() for item in list(evaluation.get("weaknesses", [])) if str(item).strip()][:6],
|
||||
}
|
||||
if failures:
|
||||
result["failures"] = failures
|
||||
result["partial"] = True
|
||||
return result
|
||||
|
||||
def _maybe_promote_reflection_skill(self, profile: dict[str, Any], reflection: dict[str, Any], project_id: str | None = None) -> str:
|
||||
employees = profile.setdefault("employees", {})
|
||||
employee_id = str(reflection.get("employee_id", "")).strip()
|
||||
record = employees.get(employee_id)
|
||||
if not record:
|
||||
return ""
|
||||
pattern_key = str(reflection.get("pattern_key", "")).strip()
|
||||
pattern = dict(record.get("patterns", {}).get(pattern_key, {}))
|
||||
if not pattern or pattern.get("learned_skill_ref"):
|
||||
return str(pattern.get("learned_skill_ref", ""))
|
||||
if int(pattern.get("reflection_count", 0)) < self.LEARNED_SKILL_THRESHOLD:
|
||||
return ""
|
||||
|
||||
repeated_working = self._repeated_items(pattern.get("working_pattern_counts", {}))
|
||||
repeated_checklists = self._repeated_items(pattern.get("checklist_counts", {}))
|
||||
repeated_reviewer = self._repeated_items(pattern.get("reviewer_preference_counts", {}))
|
||||
repeated_tools = self._repeated_items(pattern.get("tool_preference_counts", {}))
|
||||
repeated_risks = self._repeated_items(pattern.get("risk_watchout_counts", {}))
|
||||
if not any((repeated_working, repeated_checklists, repeated_reviewer, repeated_tools, repeated_risks)):
|
||||
return ""
|
||||
|
||||
employee_name = str(reflection.get("employee_name", "Employee")).strip() or "Employee"
|
||||
role_id = str(reflection.get("role_id", "")).strip() or record.get("role_id", "general")
|
||||
domains = list(reflection.get("domains", [])) or list(pattern.get("domains", [])) or [role_id]
|
||||
primary_domain = domains[0] if domains else role_id
|
||||
display_name = f"{employee_name} {role_id} {primary_domain} playbook"
|
||||
skill_name = self._normalize_skill_name(display_name)
|
||||
reflection_count = int(pattern.get("reflection_count", 0))
|
||||
sections = [
|
||||
f"# {display_name}",
|
||||
"",
|
||||
f"Learned playbook for **{employee_name}** in role `{role_id}` across {', '.join(domains)}.",
|
||||
f"Distilled from {reflection_count} project reflections.",
|
||||
]
|
||||
if repeated_working:
|
||||
sections.extend(["", "## Successful Behaviors", *[f"- {item}" for item in repeated_working]])
|
||||
if repeated_checklists:
|
||||
sections.extend(["", "## Default Checklist", *[f"- {item}" for item in repeated_checklists]])
|
||||
if repeated_reviewer:
|
||||
sections.extend(["", "## Reviewer Preferences", *[f"- {item}" for item in repeated_reviewer]])
|
||||
if repeated_tools:
|
||||
sections.extend(["", "## Tool Preferences", *[f"- {item}" for item in repeated_tools]])
|
||||
if repeated_risks:
|
||||
sections.extend(["", "## Risk Watchouts", *[f"- {item}" for item in repeated_risks]])
|
||||
avoid_for = self._rank_items(record.get("avoid_domain_counts", {}), limit=4)
|
||||
if avoid_for:
|
||||
sections.extend(["", "## Avoid For", *[f"- {item}" for item in avoid_for]])
|
||||
|
||||
skill = Skill(
|
||||
name=skill_name,
|
||||
description=(
|
||||
f"Learned playbook for `{role_id}` work ({', '.join(domains)}) by {employee_name}. "
|
||||
f"Use when assigning similar {role_id} tasks in these domains."
|
||||
),
|
||||
metadata={
|
||||
"employee_id": employee_id,
|
||||
"employee_name": employee_name,
|
||||
"role_id": role_id,
|
||||
"template_id": reflection.get("template_id", ""),
|
||||
"pattern_key": pattern_key,
|
||||
"built_from": "project_reflections",
|
||||
},
|
||||
content="\n".join(sections).strip() + "\n",
|
||||
)
|
||||
self.skills.save_skill(skill, project_id=project_id)
|
||||
self._attach_learned_skill(profile, employee_id, pattern_key, skill.name)
|
||||
return skill.name
|
||||
|
||||
@staticmethod
|
||||
def _normalize_skill_name(raw: str) -> str:
|
||||
"""Normalize to lowercase hyphen-case, matching skill-creator conventions."""
|
||||
normalized = raw.strip().lower()
|
||||
normalized = re.sub(r"[^a-z0-9]+", "-", normalized)
|
||||
normalized = normalized.strip("-")
|
||||
normalized = re.sub(r"-{2,}", "-", normalized)
|
||||
return normalized[:64]
|
||||
|
||||
def _attach_learned_skill(
|
||||
self,
|
||||
profile: dict[str, Any],
|
||||
employee_id: str,
|
||||
pattern_key: str,
|
||||
skill_name: str,
|
||||
) -> None:
|
||||
employees = profile.setdefault("employees", {})
|
||||
record = employees.setdefault(employee_id, {})
|
||||
refs = record.setdefault("learned_skill_refs", [])
|
||||
if skill_name not in refs:
|
||||
refs.append(skill_name)
|
||||
patterns = record.setdefault("patterns", {})
|
||||
pattern = patterns.setdefault(pattern_key, {})
|
||||
pattern["learned_skill_ref"] = skill_name
|
||||
record["updated_at"] = _utc_now()
|
||||
record.setdefault("delta_profile", {})
|
||||
|
||||
def _reflection_path(self, project_id: str, employee_id: str, delivery_task_id: str) -> Path:
|
||||
return self.opc_home / "projects" / project_id / "employees" / employee_id / "reflections" / f"{delivery_task_id}.yaml"
|
||||
|
||||
def _base_pattern_record(self, role_id: str, domains: list[str]) -> dict[str, Any]:
|
||||
return {
|
||||
"role_id": role_id,
|
||||
"domains": list(domains),
|
||||
"successes": 0,
|
||||
"partial_successes": 0,
|
||||
"failures": 0,
|
||||
"learned_skill_ref": "",
|
||||
"reflection_count": 0,
|
||||
}
|
||||
|
||||
def _normalize_work_item_tasks(self, work_item_tasks: list[Any], delivery_task: Any) -> list[Any]:
|
||||
tasks_by_id: dict[str, Any] = {}
|
||||
for task in work_item_tasks:
|
||||
task_id = str(getattr(task, "id", "") or "").strip()
|
||||
if task_id:
|
||||
tasks_by_id[task_id] = task
|
||||
delivery_task_id = str(getattr(delivery_task, "id", "") or "").strip()
|
||||
if delivery_task_id:
|
||||
tasks_by_id[delivery_task_id] = delivery_task
|
||||
return list(tasks_by_id.values())
|
||||
|
||||
def _collect_domains(self, tasks: list[Any], fallback: list[str]) -> list[str]:
|
||||
collected: list[str] = []
|
||||
for task in tasks:
|
||||
assignment = dict(getattr(task, "metadata", {}).get("employee_assignment", {}) or {})
|
||||
for value in list(assignment.get("domains", [])) + list(getattr(task, "tags", []) or []):
|
||||
item = str(value).strip()
|
||||
if item and item not in collected:
|
||||
collected.append(item)
|
||||
for value in fallback:
|
||||
item = str(value).strip()
|
||||
if item and item not in collected:
|
||||
collected.append(item)
|
||||
return collected
|
||||
|
||||
def _collect_task_summaries(self, tasks: list[Any]) -> list[str]:
|
||||
summaries: list[str] = []
|
||||
for task in tasks:
|
||||
for candidate in (
|
||||
str(getattr(task, "metadata", {}).get("work_item_summary_for_downstream", "") or "").strip(),
|
||||
str(getattr(task, "result", {}).get("content", "") or "").strip(),
|
||||
str(getattr(task, "title", "") or "").strip(),
|
||||
):
|
||||
if candidate and candidate not in summaries:
|
||||
summaries.append(candidate)
|
||||
break
|
||||
return summaries
|
||||
|
||||
def _collect_items(self, tasks: list[Any], key: str) -> list[str]:
|
||||
items: list[str] = []
|
||||
for task in tasks:
|
||||
for value in list(getattr(task, "metadata", {}).get(key, []) or []):
|
||||
text = str(value).strip()
|
||||
if text and text not in items:
|
||||
items.append(text)
|
||||
return items
|
||||
|
||||
def _collect_preferred_agents(self, tasks: list[Any], assignment: dict[str, Any]) -> list[str]:
|
||||
agents: list[str] = []
|
||||
assignment_agent = str(assignment.get("preferred_external_agent", "") or "").strip()
|
||||
if assignment_agent:
|
||||
agents.append(assignment_agent)
|
||||
for task in tasks:
|
||||
value = str(getattr(task, "assigned_external_agent", "") or "").strip()
|
||||
if value and value not in agents:
|
||||
agents.append(value)
|
||||
return agents
|
||||
|
||||
def _infer_avoid_domains(self, risks: list[str]) -> list[str]:
|
||||
avoid: list[str] = []
|
||||
joined = " ".join(risks).lower()
|
||||
for token in ("security", "compliance", "billing", "finance", "production", "deployment"):
|
||||
if token in joined and token not in avoid:
|
||||
avoid.append(token)
|
||||
return avoid
|
||||
|
||||
def _find_employee_feedback(self, employee_id: str, evaluation: dict[str, Any] | None) -> dict[str, Any]:
|
||||
if not evaluation:
|
||||
return {}
|
||||
for item in list(evaluation.get("employees", [])):
|
||||
if str(item.get("employee_id", "")).strip() == employee_id:
|
||||
return dict(item)
|
||||
return {}
|
||||
|
||||
def _increment_outcome_counts(self, container: dict[str, Any], outcome: str) -> None:
|
||||
normalized = self._normalize_outcome(outcome)
|
||||
if normalized == "success":
|
||||
container["successes"] = int(container.get("successes", 0)) + 1
|
||||
elif normalized == "failure":
|
||||
container["failures"] = int(container.get("failures", 0)) + 1
|
||||
else:
|
||||
container["partial_successes"] = int(container.get("partial_successes", 0)) + 1
|
||||
|
||||
def _normalize_outcome(self, outcome: str) -> str:
|
||||
normalized = str(outcome or "").strip().lower()
|
||||
if normalized in {"success", "approved", "fully_approved", "complete_success"}:
|
||||
return "success"
|
||||
if normalized in {"failure", "failed", "rejected", "fully_rejected"}:
|
||||
return "failure"
|
||||
return "partial_success"
|
||||
|
||||
def _increment_counts(self, container: dict[str, Any], key: str, items: list[str]) -> None:
|
||||
counts = container.setdefault(key, {})
|
||||
for item in self._dedupe_preserve_order(items):
|
||||
counts[item] = int(counts.get(item, 0)) + 1
|
||||
|
||||
def _build_delta_profile(self, record: dict[str, Any]) -> dict[str, Any]:
|
||||
return {
|
||||
"working_patterns": self._rank_items(record.get("working_pattern_counts", {}), limit=5),
|
||||
"default_checklists": self._rank_items(record.get("checklist_counts", {}), limit=6),
|
||||
"reviewer_preferences": self._rank_items(record.get("reviewer_preference_counts", {}), limit=5),
|
||||
"risk_watchouts": self._rank_items(record.get("risk_watchout_counts", {}), limit=5),
|
||||
"tool_preferences": self._rank_items(record.get("tool_preference_counts", {}), limit=4),
|
||||
"fit_domains": self._rank_items(record.get("fit_domain_counts", {}), limit=4),
|
||||
"avoid_domains": self._rank_items(record.get("avoid_domain_counts", {}), limit=4),
|
||||
}
|
||||
|
||||
def _normalize_self_evolution_event(
|
||||
self,
|
||||
event: dict[str, Any],
|
||||
source: dict[str, Any],
|
||||
) -> dict[str, Any]:
|
||||
employee_id = str(event.get("employee_id", "") or "").strip()
|
||||
if not employee_id:
|
||||
return {}
|
||||
event_id = str(event.get("event_id", "") or "").strip()
|
||||
if not event_id:
|
||||
checkpoint_id = str(source.get("checkpoint_id", "") or "").strip()
|
||||
role_id = str(event.get("role_id", "") or "").strip()
|
||||
nonce = json.dumps(event, ensure_ascii=False, sort_keys=True)
|
||||
digest = hashlib.sha256(nonce.encode("utf-8")).hexdigest()[:12]
|
||||
event_id = self._safe_employee_filename(f"{checkpoint_id or _utc_now()}-{employee_id}-{role_id}-{digest}")
|
||||
return {
|
||||
"event_id": event_id,
|
||||
"employee_id": employee_id,
|
||||
"role_id": str(event.get("role_id", "") or "").strip(),
|
||||
"summary": str(event.get("summary", "") or "").strip(),
|
||||
"strengths": self._string_list(event.get("strengths", []), limit=8),
|
||||
"adjustments": self._string_list(event.get("adjustments", event.get("adjust", [])), limit=8),
|
||||
"avoid_next_time": self._string_list(event.get("avoid_next_time", event.get("avoid", [])), limit=8),
|
||||
"routing_notes": self._string_list(event.get("routing_notes", []), limit=8),
|
||||
"evidence_task_ids": self._string_list(event.get("evidence_task_ids", []), limit=12),
|
||||
"confidence": self._bounded_float(event.get("confidence", 0.7), default=0.7),
|
||||
"source": dict(source or {}),
|
||||
"created_at": _utc_now(),
|
||||
}
|
||||
|
||||
def _build_self_evolution_delta(self, events: list[dict[str, Any]]) -> dict[str, Any]:
|
||||
counts: dict[str, dict[str, int]] = {
|
||||
"strengths": {},
|
||||
"adjustments": {},
|
||||
"avoid_next_time": {},
|
||||
"routing_notes": {},
|
||||
}
|
||||
for event in events:
|
||||
if not isinstance(event, dict):
|
||||
continue
|
||||
for key in counts:
|
||||
for item in self._string_list(event.get(key, []), limit=20):
|
||||
counts[key][item] = int(counts[key].get(item, 0)) + 1
|
||||
return {
|
||||
"strengths": self._rank_items(counts["strengths"], limit=8),
|
||||
"adjustments": self._rank_items(counts["adjustments"], limit=8),
|
||||
"avoid_next_time": self._rank_items(counts["avoid_next_time"], limit=8),
|
||||
"routing_notes": self._rank_items(counts["routing_notes"], limit=8),
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def _safe_employee_filename(value: str) -> str:
|
||||
safe = re.sub(r"[^A-Za-z0-9._-]+", "-", str(value or "").strip()).strip("-")
|
||||
return safe or "employee"
|
||||
|
||||
@staticmethod
|
||||
def _bounded_float(value: Any, *, default: float = 0.0) -> float:
|
||||
try:
|
||||
number = float(value)
|
||||
except (TypeError, ValueError):
|
||||
number = default
|
||||
return max(0.0, min(1.0, number))
|
||||
|
||||
@staticmethod
|
||||
def _string_list(value: Any, *, limit: int = 8) -> list[str]:
|
||||
items = value if isinstance(value, list) else [value]
|
||||
result: list[str] = []
|
||||
for item in items:
|
||||
text = str(item or "").strip()
|
||||
if text and text not in result:
|
||||
result.append(text)
|
||||
if len(result) >= limit:
|
||||
break
|
||||
return result
|
||||
|
||||
def _rank_items(self, counts: dict[str, Any], *, limit: int = 6) -> list[str]:
|
||||
ranked = sorted(
|
||||
((str(item).strip(), int(count)) for item, count in dict(counts).items() if str(item).strip()),
|
||||
key=lambda pair: (-pair[1], pair[0].lower()),
|
||||
)
|
||||
return [item for item, _count in ranked[:limit]]
|
||||
|
||||
def _repeated_items(self, counts: dict[str, Any], *, minimum: int = 2) -> list[str]:
|
||||
ranked = sorted(
|
||||
((str(item).strip(), int(count)) for item, count in dict(counts).items() if int(count) >= minimum and str(item).strip()),
|
||||
key=lambda pair: (-pair[1], pair[0].lower()),
|
||||
)
|
||||
return [item for item, _count in ranked[:6]]
|
||||
|
||||
def _pattern_key(self, role_id: str, domains: list[str]) -> str:
|
||||
domain_key = ",".join(sorted({domain.strip().lower() for domain in domains if domain.strip()}))
|
||||
return f"{role_id}|{domain_key or 'general'}"
|
||||
|
||||
def _dedupe_preserve_order(self, items: list[str]) -> list[str]:
|
||||
unique: list[str] = []
|
||||
for item in items:
|
||||
text = str(item).strip()
|
||||
if text and text not in unique:
|
||||
unique.append(text)
|
||||
return unique
|
||||
|
||||
def _deep_merge(self, base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
|
||||
merged = dict(base)
|
||||
for key, value in override.items():
|
||||
if isinstance(value, dict) and isinstance(merged.get(key), dict):
|
||||
merged[key] = self._deep_merge(merged[key], value)
|
||||
elif isinstance(value, list) and isinstance(merged.get(key), list):
|
||||
existing = list(merged[key])
|
||||
for item in value:
|
||||
if item not in existing:
|
||||
existing.append(item)
|
||||
merged[key] = existing
|
||||
else:
|
||||
merged[key] = value
|
||||
return merged
|
||||
Reference in New Issue
Block a user