@blueharford/scrypted-spatial-awareness 0.6.2 → 0.6.4

package/out/main.nodejs.js

@@ -36081,13 +36081,15 @@ Identify:
 2. Camera connections - How someone could move between camera views and estimated walking time
 3. Overall layout - Describe the property layout based on what you see
 
+IMPORTANT: For camera references, use the EXACT device ID shown in parentheses (e.g., "device_123"), NOT the camera name.
+
 Respond with ONLY valid JSON:
 {
   "sharedLandmarks": [
-    {"name": "Driveway", "type": "access", "seenByCameras": ["camera1", "camera2"], "confidence": 0.8, "description": "Concrete driveway"}
+    {"name": "Driveway", "type": "access", "seenByCameras": ["device_123", "device_456"], "confidence": 0.8, "description": "Concrete driveway"}
   ],
   "connections": [
-    {"from": "camera1", "to": "camera2", "transitSeconds": 10, "via": "driveway", "confidence": 0.7, "bidirectional": true}
+    {"from": "device_123", "to": "device_456", "transitSeconds": 10, "via": "driveway", "confidence": 0.7, "bidirectional": true}
   ],
   "layoutDescription": "Single-story house with front yard facing street, driveway on the left side, backyard accessible through side gate"
 }`;
@@ -36410,6 +36412,36 @@ class TopologyDiscoveryEngine {
             return 'west';
         return 'unknown';
     }
+    /** Resolve a camera reference (name or deviceId) to its deviceId */
+    resolveCameraRef(ref) {
+        if (!this.topology?.cameras || !ref)
+            return null;
+        // Try exact deviceId match first
+        const byId = this.topology.cameras.find(c => c.deviceId === ref);
+        if (byId)
+            return byId.deviceId;
+        // Try exact name match
+        const byName = this.topology.cameras.find(c => c.name === ref);
+        if (byName)
+            return byName.deviceId;
+        // Try case-insensitive name match
+        const refLower = ref.toLowerCase();
+        const byNameLower = this.topology.cameras.find(c => c.name.toLowerCase() === refLower);
+        if (byNameLower)
+            return byNameLower.deviceId;
+        // Try partial name match (LLM might truncate or abbreviate)
+        const byPartial = this.topology.cameras.find(c => c.name.toLowerCase().includes(refLower) || refLower.includes(c.name.toLowerCase()));
+        if (byPartial)
+            return byPartial.deviceId;
+        this.console.warn(`[Discovery] Could not resolve camera reference: "${ref}"`);
+        return null;
+    }
+    /** Normalize camera references in an array to deviceIds */
+    normalizeCameraRefs(refs) {
+        return refs
+            .map(ref => this.resolveCameraRef(ref))
+            .filter((id) => id !== null);
+    }
     /** Analyze all cameras and correlate findings */
     async runFullDiscovery() {
         if (!this.topology?.cameras?.length) {
@@ -36502,23 +36534,41 @@ class TopologyDiscoveryEngine {
                         timestamp: Date.now(),
                     };
                     if (Array.isArray(parsed.sharedLandmarks)) {
-                        correlation.sharedLandmarks = parsed.sharedLandmarks.map((l) => ({
-                            name: l.name || 'Unknown',
-                            type: this.mapLandmarkType(l.type),
-                            seenByCameras: Array.isArray(l.seenByCameras) ? l.seenByCameras : [],
-                            confidence: typeof l.confidence === 'number' ? l.confidence : 0.7,
-                            description: l.description,
-                        }));
+                        correlation.sharedLandmarks = parsed.sharedLandmarks.map((l) => {
+                            // Normalize camera references to deviceIds
+                            const rawRefs = Array.isArray(l.seenByCameras) ? l.seenByCameras : [];
+                            const normalizedRefs = this.normalizeCameraRefs(rawRefs);
+                            if (rawRefs.length > 0 && normalizedRefs.length === 0) {
+                                this.console.warn(`[Discovery] Landmark "${l.name}" has no resolvable camera refs: ${JSON.stringify(rawRefs)}`);
+                            }
+                            return {
+                                name: l.name || 'Unknown',
+                                type: this.mapLandmarkType(l.type),
+                                seenByCameras: normalizedRefs,
+                                confidence: typeof l.confidence === 'number' ? l.confidence : 0.7,
+                                description: l.description,
+                            };
+                        });
                     }
                     if (Array.isArray(parsed.connections)) {
-                        correlation.suggestedConnections = parsed.connections.map((c) => ({
-                            fromCameraId: c.from || c.fromCameraId || '',
-                            toCameraId: c.to || c.toCameraId || '',
-                            transitSeconds: typeof c.transitSeconds === 'number' ? c.transitSeconds : 15,
-                            via: c.via || '',
-                            confidence: typeof c.confidence === 'number' ? c.confidence : 0.6,
-                            bidirectional: c.bidirectional !== false,
-                        }));
+                        correlation.suggestedConnections = parsed.connections.map((c) => {
+                            // Normalize camera references to deviceIds
+                            const fromRef = c.from || c.fromCameraId || '';
+                            const toRef = c.to || c.toCameraId || '';
+                            const fromId = this.resolveCameraRef(fromRef);
+                            const toId = this.resolveCameraRef(toRef);
+                            if (!fromId || !toId) {
+                                this.console.warn(`[Discovery] Connection has unresolvable camera refs: from="${fromRef}" to="${toRef}"`);
+                            }
+                            return {
+                                fromCameraId: fromId || fromRef,
+                                toCameraId: toId || toRef,
+                                transitSeconds: typeof c.transitSeconds === 'number' ? c.transitSeconds : 15,
+                                via: c.via || '',
+                                confidence: typeof c.confidence === 'number' ? c.confidence : 0.6,
+                                bidirectional: c.bidirectional !== false,
+                            };
+                        });
                     }
                     this.console.log(`[Discovery] Correlation found ${correlation.sharedLandmarks.length} shared landmarks, ${correlation.suggestedConnections.length} connections`);
                     return correlation;
@@ -40227,9 +40277,28 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             // Calculate position for the landmark WITHIN the camera's field of view
             let position = suggestion.landmark.position;
             if (!position || (position.x === 0 && position.y === 0)) {
+                // Debug logging
+                this.console.log(`[Discovery] Processing landmark "${suggestion.landmark.name}"`);
+                this.console.log(`[Discovery] sourceCameras: ${JSON.stringify(suggestion.sourceCameras)}`);
+                this.console.log(`[Discovery] visibleFromCameras: ${JSON.stringify(suggestion.landmark.visibleFromCameras)}`);
+                this.console.log(`[Discovery] Available cameras: ${topology.cameras.map(c => `${c.name}(${c.deviceId})`).join(', ')}`);
                 // Find a camera that can see this landmark
-                const visibleCameraId = suggestion.landmark.visibleFromCameras?.[0];
-                const camera = visibleCameraId ? topology.cameras.find(c => c.deviceId === visibleCameraId) : null;
+                // PREFER sourceCameras (set from analysis.cameraId) over visibleFromCameras (from LLM parsing)
+                const sourceCameraRef = suggestion.sourceCameras?.[0];
+                const visibleCameraRef = suggestion.landmark.visibleFromCameras?.[0];
+                const cameraRef = sourceCameraRef || visibleCameraRef;
+                // Use flexible matching (deviceId, name, or case-insensitive)
+                const camera = cameraRef ? topology.cameras.find(c => c.deviceId === cameraRef ||
+                    c.name === cameraRef ||
+                    c.name.toLowerCase() === cameraRef.toLowerCase()) : null;
+                if (camera) {
+                    this.console.log(`[Discovery] Matched camera: ${camera.name} (${camera.deviceId})`);
+                    this.console.log(`[Discovery] Camera position: ${JSON.stringify(camera.floorPlanPosition)}`);
+                    this.console.log(`[Discovery] Camera FOV: ${JSON.stringify(camera.fov)}`);
+                }
+                else {
+                    this.console.warn(`[Discovery] No camera matched for ref="${cameraRef}" (source="${sourceCameraRef}", visible="${visibleCameraRef}")`);
+                }
                 if (camera?.floorPlanPosition) {
                     // Get camera's FOV direction and range (cast to any for flexible access)
                     const fov = (camera.fov || { mode: 'simple', angle: 90, direction: 0, range: 80 });
@@ -40237,7 +40306,9 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
                     const range = fov.range || 80;
                     const fovAngle = fov.angle || 90;
                     // Count existing landmarks from this camera to spread them out
-                    const existingFromCamera = (topology.landmarks || []).filter(l => l.visibleFromCameras?.includes(visibleCameraId)).length;
+                    const cameraDeviceId = camera.deviceId;
+                    const existingFromCamera = (topology.landmarks || []).filter(l => l.visibleFromCameras?.includes(cameraDeviceId) ||
+                        l.visibleFromCameras?.includes(camera.name)).length;
                     // Calculate position in front of camera within its FOV
                     // Convert direction to radians (0 = up/north, 90 = right/east)
                     const dirRad = (direction - 90) * Math.PI / 180;
@@ -40287,9 +40358,19 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             const zone = suggestion.zone;
             // Find cameras that see this zone
             const sourceCameras = suggestion.sourceCameras || [];
-            const camera = sourceCameras[0]
-                ? topology.cameras.find(c => c.deviceId === sourceCameras[0] || c.name === sourceCameras[0])
+            const cameraRef = sourceCameras[0];
+            const camera = cameraRef
+                ? topology.cameras.find(c => c.deviceId === cameraRef ||
+                    c.name === cameraRef ||
+                    c.name.toLowerCase() === cameraRef.toLowerCase())
                 : null;
+            this.console.log(`[Discovery] Processing zone "${zone.name}" from camera ref="${cameraRef}"`);
+            if (camera) {
+                this.console.log(`[Discovery] Matched camera: ${camera.name} (${camera.deviceId})`);
+            }
+            else if (cameraRef) {
+                this.console.warn(`[Discovery] No camera matched for zone source ref="${cameraRef}"`);
+            }
             // Create zone polygon WITHIN the camera's field of view
             let polygon = [];
             const timestamp = Date.now();
@@ -40361,9 +40442,13 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             const globalZoneType = this.mapZoneTypeToGlobalType(zone.type);
             const cameraZones = sourceCameras
                 .map(camRef => {
-                const cam = topology.cameras.find(c => c.deviceId === camRef || c.name === camRef);
-                if (!cam)
+                const cam = topology.cameras.find(c => c.deviceId === camRef ||
+                    c.name === camRef ||
+                    c.name.toLowerCase() === camRef.toLowerCase());
+                if (!cam) {
+                    this.console.warn(`[Discovery] GlobalZone: No camera matched for ref="${camRef}"`);
                     return null;
+                }
                 return {
                     cameraId: cam.deviceId,
                     zone: [[0, 0], [100, 0], [100, 100], [0, 100]], // Full frame default