refactor: update meta plugins to use new trait interface

Co-authored-by: aider (openai/andrew/openrouter/mistralai/mistral-medium-3.1) <aider@aider.chat>

src/meta_plugin/magic.rs

@@ -122,43 +122,108 @@ impl MetaPlugin for MagicFileMetaPlugin {
         true
     }
     
-    fn initialize(&mut self, _conn: &Connection, item_id: i64) -> Result<()> {
+    fn initialize(&mut self, item_id: i64) -> Result<PluginResponse> {
         self.item_id = Some(item_id);
-        
+
         // Initialize the magic cookie once
         let cookie = Cookie::open(Default::default())
             .map_err(|e| anyhow::anyhow!("Failed to open magic cookie: {}", e))?;
         cookie.load(&[] as &[&str])
             .map_err(|e| anyhow::anyhow!("Failed to load magic database: {}", e))?;
         self.cookie = Some(cookie);
-        
-        Ok(())
+
+        Ok(PluginResponse::default())
     }
 
-    fn finalize(&mut self, conn: &Connection) -> Result<()> {
+    fn finalize(&mut self) -> Result<PluginResponse> {
+        let mut metadata = Vec::new();
+
         // Save all magic metadata if not already saved
-        if !self.is_saved {
-            if let Err(e) = self.save_all_magic_metadata(conn) {
-                eprintln!("Warning: Failed to save magic metadata: {}", e);
+        if let Some(item_id) = self.item_id {
+            if let Some(cookie) = &self.cookie {
+                // Get mime type
+                if let Ok(mime_type) = self.get_magic_result(CookieFlags::MIME_TYPE) {
+                    if !mime_type.is_empty() {
+                        if let Some(meta) = self.create_meta(item_id, "mime_type", mime_type) {
+                            metadata.push(meta);
+                        }
+                    }
+                }
+
+                // Get mime encoding
+                if let Ok(mime_encoding) = self.get_magic_result(CookieFlags::MIME_ENCODING) {
+                    if !mime_encoding.is_empty() {
+                        if let Some(meta) = self.create_meta(item_id, "mime_encoding", mime_encoding) {
+                            metadata.push(meta);
+                        }
+                    }
+                }
+
+                // Get file type
+                if let Ok(file_type) = self.get_magic_result(CookieFlags::default()) {
+                    if !file_type.is_empty() {
+                        if let Some(meta) = self.create_meta(item_id, "file_type", file_type) {
+                            metadata.push(meta);
+                        }
+                    }
+                }
             }
         }
-        Ok(())
+
+        Ok(PluginResponse {
+            metadata: if metadata.is_empty() { None } else { Some(metadata) },
+            is_finalized: true,
+        })
     }
 
-    fn update(&mut self, data: &[u8], conn: &Connection) {
+    fn update(&mut self, data: &[u8]) -> Result<PluginResponse> {
+        let mut metadata = Vec::new();
+
         // Only collect up to max_buffer_size
         let remaining_capacity = self.max_buffer_size.saturating_sub(self.buffer.len());
         if remaining_capacity > 0 {
             let bytes_to_copy = std::cmp::min(data.len(), remaining_capacity);
             self.buffer.extend_from_slice(&data[..bytes_to_copy]);
-            
-            // Check if we've reached our buffer limit and save if so
-            if self.buffer.len() >= self.max_buffer_size && !self.is_saved {
-                if let Err(e) = self.save_all_magic_metadata(conn) {
-                    eprintln!("Warning: Failed to save magic metadata early: {}", e);
+
+            // Check if we've reached our buffer limit and return metadata
+            if self.buffer.len() >= self.max_buffer_size {
+                if let Some(item_id) = self.item_id {
+                    if let Some(cookie) = &self.cookie {
+                        // Get mime type
+                        if let Ok(mime_type) = self.get_magic_result(CookieFlags::MIME_TYPE) {
+                            if !mime_type.is_empty() {
+                                if let Some(meta) = self.create_meta(item_id, "mime_type", mime_type) {
+                                    metadata.push(meta);
+                                }
+                            }
+                        }
+
+                        // Get mime encoding
+                        if let Ok(mime_encoding) = self.get_magic_result(CookieFlags::MIME_ENCODING) {
+                            if !mime_encoding.is_empty() {
+                                if let Some(meta) = self.create_meta(item_id, "mime_encoding", mime_encoding) {
+                                    metadata.push(meta);
+                                }
+                            }
+                        }
+
+                        // Get file type
+                        if let Ok(file_type) = self.get_magic_result(CookieFlags::default()) {
+                            if !file_type.is_empty() {
+                                if let Some(meta) = self.create_meta(item_id, "file_type", file_type) {
+                                    metadata.push(meta);
+                                }
+                            }
+                        }
+                    }
                 }
             }
         }
+
+        Ok(PluginResponse {
+            metadata: if metadata.is_empty() { None } else { Some(metadata) },
+            is_finalized: !metadata.is_empty(),
+        })
     }
 
     fn meta_name(&self) -> String {