feat: improve actor-specific context selection

app/actuators/lifecycle.py

@@ -65,6 +65,20 @@ _CONTEXT_AUTO_ACCEPT_SCORE = 0.78
 _CONTEXT_AUTO_ACCEPT_MIN_SCORE = 0.3
 _MAX_CONTEXT_SELECTIONS = 5
 _AUDIT_LIMIT = 20
+_MANUAL_CONTEXT_DOMAINS = frozenset({
+    "binary_sensor",
+    "climate",
+    "cover",
+    "device_tracker",
+    "fan",
+    "humidifier",
+    "light",
+    "person",
+    "sensor",
+    "switch",
+    "weather",
+})
+_CONTEXT_SUGGESTION_LIMIT = 120
 
 
 class ActuatorReconciliationService:
@@ -91,6 +105,46 @@ class ActuatorReconciliationService:
     def get_actuator(self, actuator_entity_id: str) -> ActuatorRecord:
         return self._store.get(actuator_entity_id)
 
+    def suggest_context_options(
+        self,
+        actuator_entity_id: str,
+        *,
+        limit: int = _CONTEXT_SUGGESTION_LIMIT,
+    ) -> list[HaEntitySummary]:
+        entities = {entity.entity_id: entity for entity in self._ha_reader.read_entities()}
+        discovered = {entity.entity_id: entity for entity in self._ha_reader.discover()}
+        actuator = entities.get(actuator_entity_id)
+        if actuator is None:
+            raise KeyError("Aktuator-Konfiguration nicht gefunden.")
+        selected_ids = _selected_context_ids(self._store.get(actuator_entity_id))
+        ranked: list[tuple[float, str, HaEntitySummary]] = []
+        for entity in entities.values():
+            if entity.entity_id == actuator_entity_id or entity.domain not in _MANUAL_CONTEXT_DOMAINS:
+                continue
+            role = _manual_context_role(entity, discovered.get(entity.entity_id))
+            score, _ = _score_candidate(
+                actuator,
+                entity,
+                role,
+                context=role is not EntityRole.MEASUREMENT,
+            )
+            selected = entity.entity_id in selected_ids
+            if selected:
+                score = max(score, 1.0)
+            if not selected and score < 0.1:
+                continue
+            ranked.append((score, _context_sort_group(entity), entity))
+        ranked.sort(
+            key=lambda item: (
+                -item[0],
+                item[1],
+                item[2].area_name or "",
+                item[2].friendly_name or item[2].entity_id,
+                item[2].entity_id,
+            )
+        )
+        return [entity for _, _, entity in ranked[:limit]]
+
     def delete_actuator(self, actuator_entity_id: str) -> None:
         model_id = model_id_for_actuator(actuator_entity_id)
         self._registry.archive(model_id)
@@ -592,6 +646,47 @@ def _filter_candidates(
     return result
 
 
+def _selected_context_ids(record: ActuatorRecord) -> set[str]:
+    result = set(record.assignment.selected_context_entity_ids)
+    if record.assignment.selected_numeric_entity_id:
+        result.add(record.assignment.selected_numeric_entity_id)
+    if record.manual_override is not None:
+        result.update(record.manual_override.context_entity_ids)
+        if record.manual_override.numeric_entity_id:
+            result.add(record.manual_override.numeric_entity_id)
+    return result
+
+
+def _manual_context_role(
+    entity: HaEntitySummary,
+    discovered: DiscoveredEntity | None,
+) -> EntityRole:
+    if discovered is not None and discovered.role is not EntityRole.UNSUPPORTED:
+        return discovered.role
+    if entity.domain == "sensor":
+        return EntityRole.MEASUREMENT
+    if entity.domain == "binary_sensor":
+        return EntityRole.BINARY_CONTEXT
+    return EntityRole.CONTEXT
+
+
+def _context_sort_group(entity: HaEntitySummary) -> str:
+    device_class = entity.device_class or ""
+    if device_class in {"motion", "occupancy", "presence"}:
+        return "01_presence"
+    if device_class in {"illuminance"}:
+        return "02_brightness"
+    if device_class in {"door", "garage_door", "opening", "window"}:
+        return "03_opening"
+    if device_class in {"humidity", "moisture"}:
+        return "04_humidity"
+    if device_class in {"power", "energy", "current", "voltage"}:
+        return "05_power"
+    if entity.domain in {"light", "switch"}:
+        return "06_states"
+    return f"20_{entity.domain}_{device_class}"
+
+
 def _score_candidate(
     actuator: HaEntitySummary,
     entity: HaEntitySummary,
@@ -637,6 +732,14 @@ def _score_candidate(
     if context and role is EntityRole.BINARY_CONTEXT:
         score += 0.05
         evidence.append("Binärer Kontextsensor bevorzugt für Zusatzkontext.")
+    outdoor_tokens = {"aussen", "außen", "outdoor", "garten", "terrasse", "balkon"}
+    if entity_tokens.intersection(outdoor_tokens) and entity.device_class in {
+        "illuminance",
+        "humidity",
+        "temperature",
+    }:
+        score += 0.1
+        evidence.append("Außenmesswert ist oft als übergreifender Kontext relevant.")
     return round(min(score, 1.0), 4), evidence
 
 

app/api/v1/actuators.py

@@ -14,19 +14,6 @@ from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader
 
 router = APIRouter(prefix="/v1/actuators", tags=["actuators"])
-_MANUAL_CONTEXT_DOMAINS = frozenset({
-    "binary_sensor",
-    "climate",
-    "cover",
-    "device_tracker",
-    "fan",
-    "humidifier",
-    "light",
-    "person",
-    "sensor",
-    "switch",
-    "weather",
-})
 
 
 class ConfigureActuatorRequest(BaseModel):
@@ -62,19 +49,16 @@ def discover_actuators(ha_reader: HaReader = Depends(get_ha_reader)) -> list[HaE
 
 
 @router.get("/context-options", response_model=list[HaEntitySummary])
-def context_options(ha_reader: HaReader = Depends(get_ha_reader)) -> list[HaEntitySummary]:
-    return sorted(
-        [
-            entity
-            for entity in ha_reader.read_entities()
-            if entity.domain in _MANUAL_CONTEXT_DOMAINS
-        ],
-        key=lambda entity: (
-            entity.area_name or "",
-            entity.friendly_name or entity.entity_id,
-            entity.entity_id,
-        ),
-    )
+def context_options(
+    request: Request,
+    actuator_entity_id: str | None = Query(default=None, pattern=r"^[a-z0-9_]+\.[a-z0-9_]+$"),
+) -> list[HaEntitySummary]:
+    if actuator_entity_id is None:
+        return []
+    try:
+        return _service(request).suggest_context_options(actuator_entity_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
 
 
 @router.get("", response_model=list[ActuatorRecord])

app/main.py

@@ -100,7 +100,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.3",
+    version="0.7.4",
     lifespan=lifespan,
 )
 app.state.settings = load_settings()

app/static/index.html

@@ -51,6 +51,10 @@
     .actions button { flex:1 1 180px; margin-top:0; }
     .detail-header { display:flex; justify-content:space-between; gap:12px; align-items:flex-start; flex-wrap:wrap; }
     .manual-context { margin-top:14px; background:#111a23; border:1px solid #31404d; border-radius:14px; padding:14px; }
+    .inline-controls { display:grid; grid-template-columns:repeat(auto-fit,minmax(160px,1fr)); gap:8px; margin:8px 0; }
+    .manual-entry { min-height:80px; resize:vertical; }
+    textarea { box-sizing:border-box; width:100%; border-radius:10px; border:1px solid #3b4b5b; padding:12px; background:#101820; color:#fff; font:inherit; }
+    optgroup { color:#cfe0ec; background:#101820; }
     code { color:#cfe0ec; overflow-wrap:anywhere; }
     @media (max-width: 760px) {
       header { padding:18px 14px; }
@@ -123,6 +127,23 @@
     <label for="actuator-input">Entitätsname oder Gerät aus Home Assistant</label>
     <input id="actuator-input" list="actuator-options" placeholder="z. B. light.licht_abstellraum" autocomplete="off">
     <datalist id="actuator-options"></datalist>
+    <div class="inline-controls">
+      <div>
+        <label for="actuator-domain-filter">Typ</label>
+        <select id="actuator-domain-filter" onchange="renderActuatorSelect()">
+          <option value="">Alle steuerbaren Typen</option>
+          <option value="light">Lichter</option>
+          <option value="switch">Schalter / Helper</option>
+          <option value="cover">Rollläden / Cover</option>
+          <option value="fan">Lüftung / Ventilatoren</option>
+          <option value="humidifier">Befeuchter / Entfeuchter</option>
+        </select>
+      </div>
+      <div>
+        <label for="actuator-search">Liste durchsuchen</label>
+        <input id="actuator-search" placeholder="Raum, Gerät oder Entity" oninput="renderActuatorSelect()" autocomplete="off">
+      </div>
+    </div>
     <label for="actuator-select">Oder aus Liste wählen</label>
     <select id="actuator-select" onchange="selectActuatorFromList()">
       <option value="">Geräteliste wird geladen ...</option>
@@ -153,6 +174,7 @@ const escapeHtml = value => String(value ?? "")
 let currentActuatorId = null;
 let actuatorChoices = [];
 let contextOptions = [];
+let manualContextState = {options: [], selected: new Set()};
 
 async function api(path, options = {}) {
   const response = await fetch(path, {headers: {"Content-Type": "application/json"}, ...options});
@@ -194,6 +216,61 @@ function predictionLabel(record) {
     : "Keine fällige Aktion";
 }
 
+function entityLabel(entity) {
+  const area = entity.area_name || "Ohne Bereich";
+  const name = entity.friendly_name || entity.entity_id;
+  return `${area} - ${name} (${entity.entity_id})`;
+}
+
+function normalizedSearch(value) {
+  return String(value || "").toLowerCase().replaceAll("_", " ");
+}
+
+function matchesSearch(entity, query) {
+  if (!query) return true;
+  return normalizedSearch([
+    entity.entity_id,
+    entity.friendly_name,
+    entity.area_name,
+    entity.device_name,
+    entity.device_class,
+    entity.domain,
+  ].filter(Boolean).join(" ")).includes(query);
+}
+
+function categoryForEntity(entity) {
+  const cls = entity.device_class || "";
+  if (entity.domain === "light") return "Lichtzustände";
+  if (entity.domain === "switch") return "Schalter / Helper";
+  if (["motion", "occupancy", "presence"].includes(cls)) return "PIR / Präsenz";
+  if (["illuminance"].includes(cls)) return "Helligkeit";
+  if (["door", "garage_door", "opening", "window"].includes(cls)) return "Tür / Fenster";
+  if (["humidity", "moisture"].includes(cls)) return "Luftfeuchtigkeit";
+  if (["temperature"].includes(cls)) return "Temperatur";
+  if (["power", "energy", "current", "voltage"].includes(cls)) return "Strom / Energie";
+  if (entity.domain === "binary_sensor") return "Binäre Sensoren";
+  if (entity.domain === "sensor") return "Weitere Messsensoren";
+  return "Weitere Zustände";
+}
+
+function optionGroups(entities, selectedIds = new Set()) {
+  const groups = new Map();
+  for (const entity of entities) {
+    const category = categoryForEntity(entity);
+    if (!groups.has(category)) groups.set(category, []);
+    groups.get(category).push(entity);
+  }
+  return Array.from(groups.entries()).map(([label, items]) => `
+    <optgroup label="${escapeHtml(label)}">
+      ${items.map(entity => `
+        <option value="${escapeHtml(entity.entity_id)}" ${selectedIds.has(entity.entity_id) ? "selected" : ""}>
+          ${escapeHtml(entityLabel(entity))}
+        </option>
+      `).join("")}
+    </optgroup>
+  `).join("");
+}
+
 async function loadOverview() {
   const status = document.getElementById("status");
   const chips = document.getElementById("status-chips");
@@ -217,7 +294,7 @@ async function loadOverview() {
     status.innerHTML = `<p class="bad">${escapeHtml(error.message)}</p>`;
     chips.innerHTML = "";
   }
-  await Promise.all([loadActuatorDiscovery(), loadContextOptions(), loadConfiguredActuators()]);
+  await Promise.all([loadActuatorDiscovery(), loadConfiguredActuators()]);
 }
 
 async function loadActuatorDiscovery() {
@@ -230,24 +307,53 @@ async function loadActuatorDiscovery() {
     ]);
     const configuredIds = new Set(configured.map(record => record.actuator_entity_id));
     actuatorChoices = available.filter(entity => !configuredIds.has(entity.entity_id));
-    options.innerHTML = actuatorChoices.map(entity =>
+    options.innerHTML = actuatorChoices.slice(0, 120).map(entity =>
       `<option value="${escapeHtml(entity.entity_id)}">${escapeHtml(entity.friendly_name || entity.entity_id)}${entity.area_name ? ` (${escapeHtml(entity.area_name)})` : ""}</option>`
     ).join("");
-    select.innerHTML = [
-      `<option value="">Gerät auswählen ...</option>`,
-      ...actuatorChoices.map(entity =>
-        `<option value="${escapeHtml(entity.entity_id)}">${escapeHtml(entity.area_name || "Ohne Bereich")} - ${escapeHtml(entity.friendly_name || entity.entity_id)} (${escapeHtml(entity.entity_id)})</option>`
-      ),
-    ].join("");
+    renderActuatorSelect();
   } catch (error) {
     options.innerHTML = "";
     select.innerHTML = `<option value="">Geräteliste konnte nicht geladen werden</option>`;
   }
 }
 
-async function loadContextOptions() {
+function actuatorGroupLabel(domain) {
+  const labels = {
+    light: "Lichter",
+    switch: "Schalter / Helper",
+    cover: "Rollläden / Cover",
+    fan: "Lüftung / Ventilatoren",
+    humidifier: "Befeuchter / Entfeuchter",
+  };
+  return labels[domain] || domain;
+}
+
+function renderActuatorSelect() {
+  const select = document.getElementById("actuator-select");
+  if (!select) return;
+  const domain = document.getElementById("actuator-domain-filter")?.value || "";
+  const query = normalizedSearch(document.getElementById("actuator-search")?.value || "");
+  const filtered = actuatorChoices
+    .filter(entity => !domain || entity.domain === domain)
+    .filter(entity => matchesSearch(entity, query))
+    .slice(0, 120);
+  const domains = [...new Set(filtered.map(entity => entity.domain))].sort();
+  select.innerHTML = [
+    `<option value="">${filtered.length ? "Gerät auswählen ..." : "Keine passenden Geräte gefunden"}</option>`,
+    ...domains.map(group => `
+      <optgroup label="${escapeHtml(actuatorGroupLabel(group))}">
+        ${filtered
+          .filter(entity => entity.domain === group)
+          .map(entity => `<option value="${escapeHtml(entity.entity_id)}">${escapeHtml(entityLabel(entity))}</option>`)
+          .join("")}
+      </optgroup>
+    `),
+  ].join("");
+}
+
+async function loadContextOptions(actuatorId) {
   try {
-    contextOptions = await api("v1/actuators/context-options");
+    contextOptions = await api(`v1/actuators/context-options?actuator_entity_id=${encodeURIComponent(actuatorId)}`);
   } catch (error) {
     contextOptions = [];
   }
@@ -258,6 +364,31 @@ function selectActuatorFromList() {
   if (value) document.getElementById("actuator-input").value = value;
 }
 
+function renderManualContextSelect() {
+  const select = document.getElementById("manual-context-select");
+  if (!select) return;
+  const category = document.getElementById("manual-context-category")?.value || "";
+  const query = normalizedSearch(document.getElementById("manual-context-filter")?.value || "");
+  const selectedNow = new Set([
+    ...manualContextState.selected,
+    ...Array.from(select.selectedOptions).map(option => option.value),
+  ]);
+  const filtered = manualContextState.options
+    .filter(entity => !category || categoryForEntity(entity) === category)
+    .filter(entity => matchesSearch(entity, query))
+    .slice(0, 80);
+  select.innerHTML = filtered.length
+    ? optionGroups(filtered, selectedNow)
+    : `<option value="">Keine passenden Vorschläge</option>`;
+}
+
+function parseEntityIds(value) {
+  return String(value || "")
+    .split(/[\s,;]+/)
+    .map(item => item.trim())
+    .filter(Boolean);
+}
+
 async function configureActuator() {
   const actuatorId = (
     document.getElementById("actuator-input").value.trim()
@@ -328,6 +459,7 @@ async function showActuator(actuatorId, evaluationMessage = "") {
     } catch (_) {
       record = await api(`v1/actuators/${encodeURIComponent(actuatorId)}`);
     }
+    await loadContextOptions(actuatorId);
     const contexts = [
       record.assignment.selected_numeric_entity_id,
       ...record.assignment.selected_context_entity_ids,
@@ -343,32 +475,50 @@ async function showActuator(actuatorId, evaluationMessage = "") {
     const relatedAutomations = record.behavior.related_automations || [];
     const manualContextIds = new Set(record.assignment.selected_context_entity_ids || []);
     const numericOptions = contextOptions.filter(entity => entity.domain === "sensor");
+    const suggestedIds = new Set(contextOptions.map(entity => entity.entity_id));
+    const manualOnlyIds = [
+      record.assignment.selected_numeric_entity_id,
+      ...manualContextIds,
+    ].filter(entityId => entityId && !suggestedIds.has(entityId));
+    const contextCategories = [...new Set(contextOptions
+      .filter(entity => entity.entity_id !== record.actuator_entity_id)
+      .map(categoryForEntity))]
+      .sort();
+    manualContextState = {
+      options: contextOptions.filter(entity => entity.entity_id !== record.actuator_entity_id),
+      selected: manualContextIds,
+    };
     const manualAssignment = `
       <div class="manual-context">
         <h3>Kontext selbst festlegen</h3>
-        <p class="muted">Hier kannst du Sensoren und Zustände ergänzen, die deiner Meinung nach wichtig für den Schaltvorgang sind. Beispiele: PIR, Helligkeit außen, Luftfeuchtigkeit innen/außen oder ein Lichtzustand.</p>
+        <p class="muted">Die Vorschläge sind aktorbezogen vorsortiert. Wenn etwas fehlt, trage die Entity-ID unten manuell ein, z. B. PIR, Helligkeit außen, Luftfeuchtigkeit oder Lichtzustände.</p>
         <label for="manual-numeric-select">Optionaler Haupt-Messsensor</label>
         <select id="manual-numeric-select">
           <option value="">Keinen numerischen Hauptsensor verwenden</option>
-          ${numericOptions.map(entity => `
-            <option value="${escapeHtml(entity.entity_id)}" ${record.assignment.selected_numeric_entity_id === entity.entity_id ? "selected" : ""}>
-              ${escapeHtml(entity.area_name || "Ohne Bereich")} - ${escapeHtml(entity.friendly_name || entity.entity_id)} (${escapeHtml(entity.entity_id)})
-            </option>
-          `).join("")}
+          ${optionGroups(numericOptions, new Set([record.assignment.selected_numeric_entity_id].filter(Boolean)))}
         </select>
-        <label for="manual-context-select">Zusätzliche Kontext-Entities</label>
+        <div class="inline-controls">
+          <div>
+            <label for="manual-context-category">Kategorie</label>
+            <select id="manual-context-category" onchange="renderManualContextSelect()">
+              <option value="">Alle relevanten Vorschläge</option>
+              ${contextCategories.map(category => `<option value="${escapeHtml(category)}">${escapeHtml(category)}</option>`).join("")}
+            </select>
+          </div>
+          <div>
+            <label for="manual-context-filter">Vorschläge durchsuchen</label>
+            <input id="manual-context-filter" placeholder="z. B. treppe, bewegung, lux" oninput="renderManualContextSelect()" autocomplete="off">
+          </div>
+        </div>
+        <label for="manual-context-select">Zusätzliche Kontext-Entities aus Vorschlägen</label>
         <select id="manual-context-select" multiple>
-          ${contextOptions
-            .filter(entity => entity.entity_id !== record.actuator_entity_id)
-            .map(entity => `
-              <option value="${escapeHtml(entity.entity_id)}" ${manualContextIds.has(entity.entity_id) ? "selected" : ""}>
-                ${escapeHtml(entity.area_name || "Ohne Bereich")} - ${escapeHtml(entity.friendly_name || entity.entity_id)} (${escapeHtml(entity.entity_id)})
-              </option>
-            `).join("")}
+          ${optionGroups(manualContextState.options.slice(0, 80), manualContextIds)}
         </select>
+        <label for="manual-context-freeform">Entity-IDs manuell ergänzen</label>
+        <textarea id="manual-context-freeform" class="manual-entry" placeholder="Eine oder mehrere Entity-IDs, getrennt durch Komma, Leerzeichen oder neue Zeilen">${escapeHtml(manualOnlyIds.join("\n"))}</textarea>
         <div class="actions">
           <button onclick="saveManualAssignment('${escapeHtml(record.actuator_entity_id)}')">Diese Kontext-Auswahl speichern</button>
-          <button class="secondary" onclick="loadContextOptions().then(() => showActuator('${escapeHtml(record.actuator_entity_id)}'))">Listen neu laden</button>
+          <button class="secondary" onclick="loadContextOptions('${escapeHtml(record.actuator_entity_id)}').then(() => showActuator('${escapeHtml(record.actuator_entity_id)}'))">Vorschläge neu laden</button>
         </div>
       </div>
     `;
@@ -439,9 +589,14 @@ async function showActuator(actuatorId, evaluationMessage = "") {
 
 async function saveManualAssignment(actuatorId) {
   const numericEntityId = document.getElementById("manual-numeric-select").value || null;
-  const contextEntityIds = Array.from(
+  const selectedContextIds = Array.from(
     document.getElementById("manual-context-select").selectedOptions,
-  ).map(option => option.value);
+  ).map(option => option.value).filter(value => value.includes("."));
+  const freeformContextIds = parseEntityIds(
+    document.getElementById("manual-context-freeform").value,
+  );
+  const contextEntityIds = [...new Set([...selectedContextIds, ...freeformContextIds])]
+    .filter(entityId => entityId !== numericEntityId);
   try {
     await api(`v1/actuators/${encodeURIComponent(actuatorId)}/assignment`, {
       method: "POST",