feat: enable activity/todo/tips set interval (#66)

Author: qin-ctx

config/config.yaml

@@ -184,14 +184,22 @@ prompts:
 
 # Content generation service configuration
 content_generation:
-  enabled: true
-  auto_start: true
+  # Task configurations
+  activity:
+    enabled: true
+    interval: 900  # Seconds, minimum 600 (10 minutes), recommended 900-1800 (15-30 minutes)
+
+  tips:
+    enabled: true
+    interval: 3600  # Seconds, minimum 1800 (30 minutes), recommended 3600-7200 (1-2 hours)
 
-  # Generation switches
-  enable_report_generation: true
-  enable_activity_generation: true
-  enable_todo_generation: true
-  enable_tips_generation: true
+  todos:
+    enabled: true
+    interval: 1800  # Seconds, minimum 1800 (30 minutes), recommended 1800-3600 (30-60 minutes)
+
+  report:
+    enabled: true
+    time: "08:00"  # Daily report generation time (HH:MM)
 
 
 tools:

opencontext/config/config_manager.py

@@ -293,7 +293,7 @@ def save_user_settings(self, settings: Dict[str, Any]) -> bool:
         if not self._config:
             logger.error("Main configuration not loaded")
             return False
-            
+
         # Get user settings path
         user_setting_path = self._config.get("user_setting_path")
         if not user_setting_path:
@@ -303,15 +303,30 @@ def save_user_settings(self, settings: Dict[str, Any]) -> bool:
             dir_name = os.path.dirname(user_setting_path)
             if dir_name:
                 os.makedirs(dir_name, exist_ok=True)
-  
+
+            # Load existing user settings
             user_settings = {}
+            if os.path.exists(user_setting_path):
+                with open(user_setting_path, 'r', encoding='utf-8') as f:
+                    existing_settings = yaml.safe_load(f)
+                    if existing_settings:
+                        user_settings = existing_settings
+
+            # Update with new settings
             if "vlm_model" in settings:
                 user_settings["vlm_model"] = settings["vlm_model"]
             if "embedding_model" in settings:
                 user_settings["embedding_model"] = settings["embedding_model"]
+            if "content_generation" in settings:
+                user_settings["content_generation"] = settings["content_generation"]
+
+            # Save to file
             with open(user_setting_path, 'w', encoding='utf-8') as f:
                 yaml.dump(user_settings, f, default_flow_style=False, sort_keys=False, allow_unicode=True)
+
             logger.info(f"User settings saved successfully: {user_setting_path}")
+
+            # Merge into current config
             self._config = self.deep_merge(self._config, user_settings)
             return True
         except Exception as e:

opencontext/managers/consumption_manager.py

@@ -177,12 +177,10 @@ def initialize_completion_service(self) -> Optional[CompletionService]:
 
     def initialize_consumption_components(self) -> ConsumptionManager:
         consumption_manager = ConsumptionManager()
-        
-        # Start scheduled tasks if configured
+
+        # Start scheduled tasks (individual tasks controlled by their enabled flags)
         content_generation_config = self.config.get("content_generation", {})
-        if content_generation_config.get("enabled", True) and content_generation_config.get("auto_start", True):
-            consumption_manager.start_scheduled_tasks(content_generation_config)
-            logger.info("Content generation scheduled tasks auto-started")
+        consumption_manager.start_scheduled_tasks(content_generation_config)
 
         logger.info("Context consumption components initialization complete")
         return consumption_manager

opencontext/server/component_initializer.py

@@ -77,7 +77,6 @@ def add_screenshot(
         context_processor_callback
     ) -> Optional[str]:
         """Add a screenshot to the system."""
-        logger.info(f"Adding screenshot: path={path}, window={window}, create_time={create_time}, app={app}")
 
         # Validate inputs
         if not path:

opencontext/server/context_operations.py

@@ -8,8 +8,8 @@
 """
 
 from typing import Optional
-from pydantic import BaseModel
-from fastapi import APIRouter, Depends, Query
+from pydantic import BaseModel, Field
+from fastapi import APIRouter, Depends
 
 from opencontext.server.opencontext import OpenContext
 from opencontext.utils.logging_utils import get_logger
@@ -19,59 +19,112 @@
 logger = get_logger(__name__)
 router = APIRouter(tags=["content-generation"])
 
-@router.get("/api/content_generation/status")
-async def get_content_generation_status(
+# ==================== Data Models ====================
+
+class ActivityConfig(BaseModel):
+    """Configuration for activity task"""
+    enabled: Optional[bool] = None
+    interval: Optional[int] = Field(None, ge=600, description="Interval in seconds, minimum 600 (10 minutes)")
+
+
+class TipsConfig(BaseModel):
+    """Configuration for tips task"""
+    enabled: Optional[bool] = None
+    interval: Optional[int] = Field(None, ge=1800, description="Interval in seconds, minimum 1800 (30 minutes)")
+
+
+class TodosConfig(BaseModel):
+    """Configuration for todos task"""
+    enabled: Optional[bool] = None
+    interval: Optional[int] = Field(None, ge=1800, description="Interval in seconds, minimum 1800 (30 minutes)")
+
+
+class ReportConfig(BaseModel):
+    """Configuration for daily report"""
+    enabled: Optional[bool] = None
+    time: Optional[str] = Field(None, pattern=r"^\d{2}:\d{2}$", description="Time in HH:MM format")
+
+
+class ContentGenerationConfig(BaseModel):
+    """Complete content generation configuration"""
+    activity: Optional[ActivityConfig] = None
+    tips: Optional[TipsConfig] = None
+    todos: Optional[TodosConfig] = None
+    report: Optional[ReportConfig] = None
+
+
+@router.get("/api/content_generation/config")
+async def get_content_generation_config(
     opencontext: OpenContext = Depends(get_context_lab),
     _auth: str = auth_dependency
 ):
-    """Get content generation service status"""
+    """
+    Get content generation configuration
+    """
     try:
         if not hasattr(opencontext, 'consumption_manager') or not opencontext.consumption_manager:
-            return convert_resp(data={
-                "enabled": False,
-                "message": "Consumption manager not initialized"
-            })
-        
-        status = opencontext.consumption_manager.get_scheduled_tasks_status()
-        return convert_resp(data=status)
-        
+            return convert_resp(code=500, status=500, message="Consumption manager not initialized")
+
+        config = opencontext.consumption_manager.get_task_config()
+        return convert_resp(data=config)
+
     except Exception as e:
-        logger.exception(f"Error getting content generation status: {e}")
-        return convert_resp(code=500, status=500, message=f"Failed to get status: {str(e)}")
+        logger.exception(f"Error getting content generation config: {e}")
+        return convert_resp(code=500, status=500, message=f"Failed to get config: {str(e)}")
 
 
-@router.post("/api/content_generation/start")
-async def start_content_generation(
+@router.post("/api/content_generation/config")
+async def update_content_generation_config(
+    config: ContentGenerationConfig,
     opencontext: OpenContext = Depends(get_context_lab),
     _auth: str = auth_dependency
 ):
-    """Start content generation scheduled tasks"""
+    """
+    Update content generation configuration (supports partial updates)
+    """
     try:
         if not hasattr(opencontext, 'consumption_manager') or not opencontext.consumption_manager:
             return convert_resp(code=500, status=500, message="Consumption manager not initialized")
-        
-        content_generation_config = opencontext.config.get("content_generation", {})
-        opencontext.consumption_manager.start_scheduled_tasks(content_generation_config)
-        
-        return convert_resp(data={"message": "Content generation tasks started"})
-        
-    except Exception as e:
-        logger.exception(f"Error starting content generation: {e}")
-        return convert_resp(code=500, status=500, message=f"Failed to start: {str(e)}")
+        config_dict = {}
+        for task_name in ['activity', 'tips', 'todos']:
+            task_config = getattr(config, task_name, None)
+            if task_config is not None:
+                task_dict = {}
+                if task_config.enabled is not None:
+                    task_dict['enabled'] = task_config.enabled
+                if task_config.interval is not None:
+                    task_dict['interval'] = task_config.interval
+                if task_dict:
+                    config_dict[task_name] = task_dict
+        if config.report is not None:
+            report_dict = {}
+            if config.report.enabled is not None:
+                report_dict['enabled'] = config.report.enabled
+            if config.report.time is not None:
+                report_dict['time'] = config.report.time
+            if report_dict:
+                config_dict['report'] = report_dict
 
+        if not config_dict:
+            return convert_resp(code=400, status=400, message="No valid configuration provided")
+
+        if opencontext.consumption_manager.update_task_config(config_dict):
+            try:
+                from opencontext.config.global_config import GlobalConfig
+                config_manager = GlobalConfig.get_instance().get_config_manager()
+
+                # Get current user settings and update content_generation section
+                updated_config = opencontext.consumption_manager.get_task_config()
+                config_manager.save_user_settings({"content_generation": updated_config})
+                logger.info("Configuration saved to user_settings.yaml")
+            except Exception as e:
+                logger.error(f"Failed to save configuration to file: {e}")
+                # Continue even if save fails - configuration is still applied in memory
+
+            return convert_resp(message="Configuration updated successfully")
+        else:
+            return convert_resp(code=500, status=500, message="Failed to update configuration")
 
-@router.post("/api/content_generation/stop")
-async def stop_content_generation(
-    opencontext: OpenContext = Depends(get_context_lab),
-    _auth: str = auth_dependency
-):
-    """Stop content generation scheduled tasks"""
-    try:
-        if hasattr(opencontext, 'consumption_manager') and opencontext.consumption_manager:
-            opencontext.consumption_manager.stop_scheduled_tasks()
-        
-        return convert_resp(data={"message": "Content generation tasks stopped"})
-        
     except Exception as e:
-        logger.exception(f"Error stopping content generation: {e}")
-        return convert_resp(code=500, status=500, message=f"Failed to stop: {str(e)}")
+        logger.exception(f"Error updating content generation config: {e}")
+        return convert_resp(code=500, status=500, message=f"Failed to update config: {str(e)}")