Tighten context onboarding and actuator suggestions

2026-06-16 12:06:03 +02:00
parent 18999ff68a
commit 1b2b76455a
12 changed files with 310 additions and 8 deletions
--- a/app/actuators/lifecycle.py
+++ b/app/actuators/lifecycle.py
@@ -57,7 +57,7 @@ _STOPWORDS = frozenset(
        "value",
    }
 )
-_GENERIC_AREA_NAMES = frozenset({"monitoring", "system", "technik"})
+_GENERIC_AREA_NAMES = frozenset({"energie", "monitoring", "power", "strom", "system", "technik"})
 _NUMERIC_AUTO_ACCEPT_SCORE = 0.82
 _NUMERIC_AUTO_ACCEPT_MIN_SCORE = 0.5
 _NUMERIC_MIN_MARGIN = 0.18
@@ -88,6 +88,7 @@ _DIAGNOSTIC_TOKENS = frozenset({
    "diagnostic",
    "firmware",
    "gesehen",
+    "heat",
    "last",
    "linkquality",
    "knoten",
@@ -100,10 +101,28 @@ _DIAGNOSTIC_TOKENS = frozenset({
    "signal",
    "ssid",
    "status",
+    "overheat",
+    "overheating",
+    "overload",
    "uptime",
+    "uberhitzung",
+    "ueberhitzung",
+    "ueberlast",
+    "überhitzung",
+    "überlast",
    "wifi",
    "zuletzt",
 })
+_AUTO_CONTEXT_CLASSES = frozenset({
+    "door",
+    "garage_door",
+    "illuminance",
+    "motion",
+    "occupancy",
+    "opening",
+    "presence",
+    "window",
+})


 class ActuatorReconciliationService:
@@ -628,8 +647,12 @@ class ActuatorReconciliationService:
                if context
                else _NUMERIC_AUTO_ACCEPT_MIN_SCORE
            )
+            can_auto_accept_context = (
+                not context or _eligible_for_auto_context(actuator, candidate)
+            )
            auto_accepted = (
-                candidate.score >= minimum_score
+                can_auto_accept_context
+                and candidate.score >= minimum_score
                and confidence >= auto_score
                and (context or margin >= _NUMERIC_MIN_MARGIN)
            )
@@ -743,6 +766,23 @@ def _has_context_relationship(actuator: HaEntitySummary, entity: HaEntitySummary
    )


+def _eligible_for_auto_context(
+    actuator: HaEntitySummary,
+    candidate: AssignmentCandidate,
+) -> bool:
+    device_class = candidate.device_class or ""
+    if device_class in _AUTO_CONTEXT_CLASSES:
+        return True
+    if (
+        actuator.device_name
+        and candidate.device_name
+        and actuator.device_name == candidate.device_name
+        and candidate.domain in {"light", "switch"}
+    ):
+        return True
+    return False
+
+
 def _score_candidate(
    actuator: HaEntitySummary,
    entity: HaEntitySummary,
--- a/app/api/v1/actuators.py
+++ b/app/api/v1/actuators.py
@@ -8,7 +8,7 @@ from app.actuators.models import ActuatorRecord, ReconciliationState
 from app.actuators.store import ActuatorStore
 from app.behavior.engine import BehaviorEngine
 from app.dependencies import get_ha_reader
-from app.ha.discovery import EntityRole
+from app.ha.discovery import DiscoveredEntity, EntityRole
 from app.ha.exceptions import HaClientError
 from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader
@@ -43,6 +43,18 @@ class FeedbackRequest(BaseModel):
    expected_state: str | None = Field(default=None, max_length=100)


+class ActuatorSuggestion(BaseModel):
+    entity_id: str
+    domain: str
+    friendly_name: str | None = None
+    area_name: str | None = None
+    device_name: str | None = None
+    confidence: float
+    reason: str
+    related_automation_count: int = 0
+    likely_context_count: int = 0
+
+
@router.get("/discovery", response_model=list[HaEntitySummary])
 def discover_actuators(ha_reader: HaReader = Depends(get_ha_reader)) -> list[HaEntitySummary]:
    entities = {entity.entity_id: entity for entity in ha_reader.read_entities()}
@@ -58,6 +70,66 @@ def discover_actuators(ha_reader: HaReader = Depends(get_ha_reader)) -> list[HaE
    return [entities[entity_id] for entity_id in actuator_ids if entity_id in entities]


+@router.get("/suggestions", response_model=list[ActuatorSuggestion])
+def suggest_actuators(
+    request: Request,
+    ha_reader: HaReader = Depends(get_ha_reader),
+) -> list[ActuatorSuggestion]:
+    entities = {entity.entity_id: entity for entity in ha_reader.read_entities()}
+    discovered = {entity.entity_id: entity for entity in ha_reader.discover()}
+    configured_ids = {record.actuator_entity_id for record in _service(request).list_configured()}
+    actuator_ids = _deduplicate_actuator_ids(
+        [
+            (entity.entity_id, entity.category)
+            for entity in discovered.values()
+            if entity.role is EntityRole.ACTUATOR
+        ],
+        entities,
+    )
+    suggestions: list[ActuatorSuggestion] = []
+    for entity_id in actuator_ids:
+        if entity_id in configured_ids:
+            continue
+        entity = entities.get(entity_id)
+        if entity is None:
+            continue
+        try:
+            automations = ha_reader.find_automations_for_entity(entity_id)
+        except Exception:
+            automations = []
+        context_count = _likely_context_count(entity, entities, discovered)
+        if not automations and context_count == 0:
+            continue
+        confidence = 1.0 if automations else min(0.85, 0.35 + context_count * 0.1)
+        reason_parts = []
+        if automations:
+            reason_parts.append(f"{len(automations)} passende HA-Automation(en)")
+        if context_count:
+            reason_parts.append(f"{context_count} naheliegende Kontext-Entity(s)")
+        suggestions.append(
+            ActuatorSuggestion(
+                entity_id=entity.entity_id,
+                domain=entity.domain,
+                friendly_name=entity.friendly_name,
+                area_name=entity.area_name,
+                device_name=entity.device_name,
+                confidence=round(confidence, 4),
+                reason=", ".join(reason_parts),
+                related_automation_count=len(automations),
+                likely_context_count=context_count,
+            )
+        )
+    return sorted(
+        suggestions,
+        key=lambda item: (
+            -item.related_automation_count,
+            -item.confidence,
+            item.area_name or "",
+            item.friendly_name or item.entity_id,
+        ),
+    )[:30]
+
+
@router.get("/context-options", response_model=list[HaEntitySummary])
 def context_options(
    request: Request,
@@ -294,3 +366,67 @@ def _actuator_duplicate_key(entity: HaEntitySummary, category: str) -> str:
    if entity.device_name and category in {"light", "switch_socket", "button"}:
        return f"device-name:{entity.device_name.lower()}:control"
    return f"entity:{entity.entity_id}"
+
+
+def _likely_context_count(
+    actuator: HaEntitySummary,
+    entities: dict[str, HaEntitySummary],
+    discovered: dict[str, DiscoveredEntity],
+) -> int:
+    actuator_tokens = _tokens(actuator)
+    count = 0
+    for entity in entities.values():
+        if entity.entity_id == actuator.entity_id:
+            continue
+        descriptor = discovered.get(entity.entity_id)
+        role = descriptor.role if descriptor is not None else None
+        if role not in {
+            EntityRole.MEASUREMENT,
+            EntityRole.BINARY_CONTEXT,
+            EntityRole.CONTEXT,
+        }:
+            continue
+        if entity.device_class not in {
+            "door",
+            "energy",
+            "garage_door",
+            "humidity",
+            "illuminance",
+            "motion",
+            "occupancy",
+            "opening",
+            "power",
+            "presence",
+            "temperature",
+            "window",
+        }:
+            continue
+        same_area = bool(
+            actuator.area_name
+            and entity.area_name
+            and actuator.area_name == entity.area_name
+        )
+        same_device = bool(
+            actuator.device_id
+            and entity.device_id
+            and actuator.device_id == entity.device_id
+        )
+        token_match = bool(actuator_tokens.intersection(_tokens(entity)))
+        if same_area or same_device or token_match:
+            count += 1
+    return count
+
+
+def _tokens(entity: HaEntitySummary) -> set[str]:
+    values = [
+        entity.entity_id,
+        entity.friendly_name,
+        entity.area_name,
+        entity.device_name,
+    ]
+    tokens: set[str] = set()
+    for value in values:
+        if not value:
+            continue
+        tokens.update(token for token in value.lower().replace("_", " ").split() if len(token) > 2)
+    return tokens
--- a/app/behavior/engine.py
+++ b/app/behavior/engine.py
@@ -898,7 +898,7 @@ def predict_behavior(


 def service_for_state(domain: str, target_state: str) -> str | None:
-    if domain in {"fan", "humidifier", "light", "switch"}:
+    if domain in {"fan", "humidifier", "light", "media_player", "remote", "switch"}:
        return {"on": "turn_on", "off": "turn_off"}.get(target_state)
    if domain == "cover":
        return {"open": "open_cover", "closed": "close_cover"}.get(target_state)
--- a/app/ha/discovery.py
+++ b/app/ha/discovery.py
@@ -92,7 +92,9 @@ _ACTUATOR_DOMAINS = frozenset({
    "input_button",
    "lock",
    "light",
+    "media_player",
    "number",
+    "remote",
    "siren",
    "switch",
    "valve",
@@ -225,6 +227,8 @@ def _actuator_category(entity: HaEntitySummary) -> str:
        return "lock"
    if entity.domain == "fan":
        return "fan"
+    if entity.domain in {"media_player", "remote"}:
+        return "media_tv"
    if entity.domain in {"input_boolean", "number"}:
        return "helper"
    return entity.domain
--- a/app/main.py
+++ b/app/main.py
@@ -102,7 +102,7 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 app = FastAPI(
    title="SillyHome Next API",
    description="Lokales Smart-Home-Intelligenzsystem für Home Assistant.",
-    version="0.7.12",
+    version="0.7.13",
    lifespan=lifespan,
 )
 app.state.settings = load_settings()
--- a/app/static/index.html
+++ b/app/static/index.html
@@ -142,6 +142,8 @@
          <option value="lock">Schlösser</option>
          <option value="fan">Lüftung / Ventilatoren</option>
          <option value="humidifier">Befeuchter / Entfeuchter</option>
+          <option value="media_player">TV / Medien</option>
+          <option value="remote">Fernbedienungen</option>
          <option value="number">Numerische Helper</option>
          <option value="valve">Ventile</option>
        </select>
@@ -157,6 +159,7 @@
    </select>
    <button onclick="configureActuator()">Gerät hinzufügen und Beobachtung starten</button>
    <p id="actuator-config-result" class="muted">Noch kein Aktor ausgewählt.</p>
+    <div id="actuator-suggestions" class="card-list"></div>
  </section>

  <section class="wide" id="observed">
@@ -302,7 +305,11 @@ async function loadOverview() {
    status.innerHTML = `<p class="bad">${escapeHtml(error.message)}</p>`;
    chips.innerHTML = "";
  }
-  await Promise.all([loadActuatorDiscovery(), loadConfiguredActuators()]);
+  await Promise.all([
+    loadActuatorDiscovery(),
+    loadActuatorSuggestions(),
+    loadConfiguredActuators(),
+  ]);
 }

 async function loadActuatorDiscovery() {
@@ -325,6 +332,32 @@ async function loadActuatorDiscovery() {
  }
 }

+async function loadActuatorSuggestions() {
+  const box = document.getElementById("actuator-suggestions");
+  if (!box) return;
+  try {
+    const suggestions = await api("v1/actuators/suggestions");
+    box.innerHTML = suggestions.length ? `
+      <h3>Vorschläge aus bestehenden Zusammenhängen</h3>
+      ${suggestions.slice(0, 8).map(item => `
+        <article class="actuator-card">
+          <div class="card-title">
+            <div>
+              <div class="entity-id">${escapeHtml(item.entity_id)}</div>
+              <div class="muted">${escapeHtml(item.area_name || item.device_name || item.domain)}</div>
+            </div>
+            <span class="chip">${Math.round(item.confidence * 100)} %</span>
+          </div>
+          <p class="muted">${escapeHtml(item.reason)}</p>
+          <button class="secondary" onclick="configureSuggestedActuator('${escapeHtml(item.entity_id)}')">Vorschlag übernehmen</button>
+        </article>
+      `).join("")}
+    ` : "";
+  } catch (_) {
+    box.innerHTML = "";
+  }
+}
+
 function actuatorGroupLabel(domain) {
  const labels = {
    button: "Buttons",
@@ -333,7 +366,9 @@ function actuatorGroupLabel(domain) {
    input_boolean: "Helper-Schalter",
    input_button: "Helper-Buttons",
    lock: "Schlösser",
+    media_player: "TV / Medien",
    number: "Numerische Helper",
+    remote: "Fernbedienungen",
    switch: "Schalter / Steckdosen",
    cover: "Rollläden / Cover",
    fan: "Lüftung / Ventilatoren",
@@ -486,6 +521,14 @@ async function showActuator(actuatorId, evaluationMessage = "") {
      .filter(candidate => contexts.includes(candidate.entity_id))
      .map(candidate => `<li><strong>${escapeHtml(candidate.friendly_name || candidate.entity_id)}</strong>: ${candidate.evidence.map(escapeHtml).join(", ") || "statistisch relevanter Kandidat"}</li>`)
      .join("");
+    const currentContextControls = contexts.length
+      ? `<ul>${contexts.map(entityId => `
+          <li>
+            <code>${escapeHtml(entityId)}</code>
+            <button class="secondary compact" onclick="removeContextEntity('${escapeHtml(record.actuator_entity_id)}', '${escapeHtml(entityId)}')">Entfernen</button>
+          </li>
+        `).join("")}</ul>`
+      : "<p class='muted'>Noch keine Kontext-Entity ausgewählt.</p>";
    const prediction = record.behavior.prediction;
    const learnedAutomationActions = record.behavior.patterns.filter(
      pattern => pattern.source === "automation",
@@ -601,6 +644,8 @@ async function showActuator(actuatorId, evaluationMessage = "") {
      ${automationControls}
      <h3>Welche Zusammenhänge automatisch verwendet werden</h3>
      ${evidence ? `<ul>${evidence}</ul>` : "<p class='warn'>Noch kein geeigneter Kontext erkannt. SillyHome prüft bei neuen HA-Daten erneut.</p>"}
+      <h3>Verwendete Sensoren/Zustände ändern</h3>
+      ${currentContextControls}
      ${manualAssignment}
    `;
    document.getElementById("detail").scrollIntoView({behavior: "smooth", block: "start"});
@@ -635,6 +680,34 @@ async function saveManualAssignment(actuatorId) {
  }
 }

+async function removeContextEntity(actuatorId, entityId) {
+  try {
+    const record = await api(`v1/actuators/${encodeURIComponent(actuatorId)}`);
+    const numericEntityId = record.assignment.selected_numeric_entity_id === entityId
+      ? null
+      : record.assignment.selected_numeric_entity_id;
+    const contextEntityIds = (record.assignment.selected_context_entity_ids || [])
+      .filter(id => id !== entityId);
+    await api(`v1/actuators/${encodeURIComponent(actuatorId)}/assignment`, {
+      method: "POST",
+      body: JSON.stringify({
+        numeric_entity_id: numericEntityId,
+        context_entity_ids: contextEntityIds,
+        note: `Entity ${entityId} entfernt`,
+      }),
+    });
+    await loadConfiguredActuators();
+    await showActuator(actuatorId, "Kontext-Entity entfernt.");
+  } catch (error) {
+    alert(error.message);
+  }
+}
+
+async function configureSuggestedActuator(actuatorId) {
+  document.getElementById("actuator-input").value = actuatorId;
+  await configureActuator();
+}
+
 async function evaluateActuator(actuatorId) {
  try {
    const record = await api(