Forgot to update the configure.ac file.

configure.ac

@@ -133,7 +133,6 @@ src/cthulhu/plugins/DisplayVersion/Makefile
 src/cthulhu/plugins/hello_world/Makefile
 src/cthulhu/plugins/CapsLockHack/Makefile
 src/cthulhu/plugins/self_voice/Makefile
-src/cthulhu/plugins/Date/Makefile
 src/cthulhu/plugins/Time/Makefile
 src/cthulhu/plugins/MouseReview/Makefile
 src/cthulhu/plugins/SimplePluginSystem/Makefile

src/cthulhu/cthulhu.py

@@ -1018,6 +1018,8 @@ class Cthulhu(GObject.Object):
         self.APIHelper = APIHelper(self)
         self.createCompatAPI()
         self.pluginSystemManager = plugin_system_manager.PluginSystemManager(self)
+        # Scan for available plugins at startup
+        self.pluginSystemManager.rescanPlugins()
     def getAPIHelper(self):
         return self.APIHelper
     def getPluginSystemManager(self):

src/cthulhu/cthulhuVersion.py

@@ -23,5 +23,5 @@
 # Fork of Orca Screen Reader (GNOME)
 # Original source: https://gitlab.gnome.org/GNOME/orca
 
-version = "2025.04.03"
+version = "2025.04.04"
 codeName = "testing"

src/cthulhu/plugin.py

@@ -16,6 +16,7 @@ try:
     import pluggy
     cthulhu_hookimpl = pluggy.HookimplMarker("cthulhu")
     PLUGGY_AVAILABLE = True
+    logging.getLogger(__name__).info("Successfully imported pluggy")
 except ImportError:
     # Fallback if pluggy is not available
     def cthulhu_hookimpl(func=None, **kwargs):
@@ -29,7 +30,9 @@ except ImportError:
             return lambda f: f
         return func
     PLUGGY_AVAILABLE = False
-    logging.getLogger(__name__).info("Pluggy not available, plugins will be disabled")
+    logging.getLogger(__name__).warning("Pluggy not available, plugins will be disabled")
+    import traceback
+    logging.getLogger(__name__).debug(traceback.format_exc())
 
 logger = logging.getLogger(__name__)
 

src/cthulhu/plugin_system_manager.py

@@ -22,7 +22,12 @@ except ImportError:
     PLUGGY_AVAILABLE = False
     logging.getLogger(__name__).info("Pluggy not available, plugins will be disabled")
 
+# Set to True for more detailed plugin loading debug info
+PLUGIN_DEBUG = True
+
 logger = logging.getLogger(__name__)
+if PLUGIN_DEBUG:
+    logger.setLevel(logging.DEBUG)
 
 class PluginType(IntEnum):
     """Types of plugins we support."""
@@ -74,9 +79,11 @@ class PluginSystemManager:
 
     def __init__(self, app):
         self.app = app
+        logger.info("Initializing PluginSystemManager")
 
         # Initialize plugin manager
         if PLUGGY_AVAILABLE:
+            logger.info("Pluggy is available, setting up plugin manager")
             self.plugin_manager = pluggy.PluginManager("cthulhu")
 
             # Define hook specifications
@@ -93,8 +100,10 @@ class PluginSystemManager:
                     """Called when the plugin is deactivated."""
                     pass
 
+            logger.info("Adding hook specifications to plugin manager")
             self.plugin_manager.add_hookspecs(CthulhuHookSpecs)
         else:
+            logger.warning("Pluggy is not available, plugins will be disabled")
             self.plugin_manager = None
 
         # Plugin storage
@@ -103,6 +112,10 @@ class PluginSystemManager:
 
         # Create plugin directories
         self._setup_plugin_dirs()
+        
+        # Log available plugins directory paths
+        logger.info(f"System plugins directory: {PluginType.SYSTEM.get_root_dir()}")
+        logger.info(f"User plugins directory: {PluginType.USER.get_root_dir()}")
 
     def _setup_plugin_dirs(self):
         """Ensure plugin directories exist."""
@@ -136,19 +149,31 @@ class PluginSystemManager:
     def _scan_plugins_in_directory(self, directory):
         """Scan for plugins in a directory."""
         if not os.path.exists(directory) or not os.path.isdir(directory):
+            logger.warning(f"Plugin directory not found or not a directory: {directory}")
             return
 
+        logger.info(f"Scanning for plugins in directory: {directory}")
         for item in os.listdir(directory):
             plugin_dir = os.path.join(directory, item)
             if not os.path.isdir(plugin_dir):
                 continue
 
+            # Check for the traditional structure first (plugin.py & plugin.info)
             plugin_file = os.path.join(plugin_dir, "plugin.py")
             metadata_file = os.path.join(plugin_dir, "plugin.info")
 
+            # Fall back to [PluginName].py if plugin.py doesn't exist
+            if not os.path.isfile(plugin_file):
+                alternative_plugin_file = os.path.join(plugin_dir, f"{item}.py")
+                if os.path.isfile(alternative_plugin_file):
+                    plugin_file = alternative_plugin_file
+                    logger.info(f"Using alternative plugin file: {alternative_plugin_file}")
+
+            # Check if we have any valid plugin file
             if os.path.isfile(plugin_file):
                 # Extract plugin info
                 module_name = os.path.basename(plugin_dir)
+                logger.info(f"Found plugin: {module_name} in {plugin_dir}")
                 metadata = self._load_plugin_metadata(metadata_file)
 
                 plugin_info = PluginInfo(
@@ -162,7 +187,10 @@ class PluginSystemManager:
                 plugin_info.builtin = metadata.get('builtin', 'false').lower() == 'true'
                 plugin_info.hidden = metadata.get('hidden', 'false').lower() == 'true'
 
+                logger.info(f"Adding plugin to registry: {module_name}")
                 self._plugins[module_name] = plugin_info
+            else:
+                logger.warning(f"No plugin file found in directory: {plugin_dir}")
 
     def _load_plugin_metadata(self, metadata_file):
         """Load plugin metadata from a file."""
@@ -190,7 +218,25 @@ class PluginSystemManager:
 
     def setActivePlugins(self, activePlugins):
         """Set active plugins and sync their state."""
+        logger.info(f"Setting active plugins: {activePlugins}")
+        
+        # Make sure we have scanned for plugins first
+        if not self._plugins:
+            logger.info("No plugins found, rescanning...")
+            self.rescanPlugins()
+            
         self._active_plugins = activePlugins
+        
+        # Log active vs available plugins
+        available_plugins = [p.get_module_name() for p in self.plugins]
+        logger.info(f"Available plugins: {available_plugins}")
+        logger.info(f"Active plugins: {self._active_plugins}")
+        
+        # Find missing plugins
+        missing_plugins = [p for p in self._active_plugins if p not in available_plugins]
+        if missing_plugins:
+            logger.warning(f"Active plugins not found: {missing_plugins}")
+            
         self.syncAllPluginsActive()
 
     def setPluginActive(self, pluginInfo, active):
@@ -211,25 +257,66 @@ class PluginSystemManager:
 
     def isPluginActive(self, pluginInfo):
         """Check if a plugin is active."""
+        module_name = pluginInfo.get_module_name()
+        
+        # Builtin plugins are always active
         if pluginInfo.builtin:
+            logger.debug(f"Plugin {module_name} is builtin, active by default")
             return True
 
+        # If a plugin is already loaded, it's active
         if pluginInfo.loaded:
+            logger.debug(f"Plugin {module_name} is already loaded, considered active")
             return True
 
-        return pluginInfo.get_module_name() in self.getActivePlugins()
+        # Check case-insensitive match in active plugins list
+        active_plugins = self.getActivePlugins()
+        
+        # Try exact match first
+        if module_name in active_plugins:
+            logger.debug(f"Plugin {module_name} found in active plugins list")
+            return True
+            
+        # Try case-insensitive match
+        module_name_lower = module_name.lower()
+        is_active = any(plugin.lower() == module_name_lower for plugin in active_plugins)
+        
+        if is_active:
+            logger.debug(f"Plugin {module_name} found in active plugins list (case-insensitive match)")
+        else:
+            logger.debug(f"Plugin {module_name} not found in active plugins list")
+            
+        return is_active
 
     def syncAllPluginsActive(self):
         """Sync the active state of all plugins."""
+        logger.info("Syncing active state of all plugins")
+        
+        # Log plugin status before syncing
+        if PLUGIN_DEBUG:
+            for pluginInfo in self.plugins:
+                is_active = self.isPluginActive(pluginInfo)
+                is_loaded = pluginInfo.loaded
+                logger.debug(f"Plugin {pluginInfo.get_module_name()}: active={is_active}, loaded={is_loaded}")
+        
         # First unload inactive plugins
         for pluginInfo in self.plugins:
             if not self.isPluginActive(pluginInfo) and pluginInfo.loaded:
+                logger.info(f"Unloading inactive plugin: {pluginInfo.get_module_name()}")
                 self.unloadPlugin(pluginInfo)
 
         # Then load active plugins
         for pluginInfo in self.plugins:
             if self.isPluginActive(pluginInfo) and not pluginInfo.loaded:
-                self.loadPlugin(pluginInfo)
+                logger.info(f"Loading active plugin: {pluginInfo.get_module_name()}")
+                result = self.loadPlugin(pluginInfo)
+                logger.info(f"Plugin {pluginInfo.get_module_name()} load result: {result}")
+        
+        # Log final plugin status
+        active_plugins = [p.get_module_name() for p in self.plugins if p.loaded]
+        logger.info(f"Active plugins after sync: {active_plugins}")
+        inactive_plugins = [p.get_module_name() for p in self.plugins if not p.loaded]
+        logger.info(f"Inactive plugins after sync: {inactive_plugins}")
 
     def loadPlugin(self, pluginInfo):
         """Load a plugin."""
@@ -239,15 +326,38 @@ class PluginSystemManager:
             return False
 
         module_name = pluginInfo.get_module_name()
+        logger.info(f"Attempting to load plugin: {module_name}")
 
         try:
             # Already loaded?
             if pluginInfo.loaded:
+                logger.info(f"Plugin {module_name} already loaded, skipping")
                 return True
 
-            # Import plugin module
-            plugin_file = os.path.join(pluginInfo.get_module_dir(), "plugin.py")
+            # Try to find the plugin file
+            module_name = pluginInfo.get_module_name()
+            plugin_dir = pluginInfo.get_module_dir()
+            
+            # Check for plugin.py first (standard format)
+            plugin_file = os.path.join(plugin_dir, "plugin.py")
+            
+            # Fall back to [PluginName].py if plugin.py doesn't exist
+            if not os.path.exists(plugin_file):
+                alternative_plugin_file = os.path.join(plugin_dir, f"{module_name}.py")
+                if os.path.exists(alternative_plugin_file):
+                    plugin_file = alternative_plugin_file
+                    logger.info(f"Using alternative plugin file: {alternative_plugin_file}")
+            
+            if not os.path.exists(plugin_file):
+                logger.error(f"Plugin file not found: {plugin_file}")
+                return False
+                
+            logger.info(f"Loading plugin from: {plugin_file}")
             spec = importlib.util.spec_from_file_location(module_name, plugin_file)
+            if spec is None:
+                logger.error(f"Failed to create spec for plugin: {module_name}")
+                return False
+                
             module = importlib.util.module_from_spec(spec)
             spec.loader.exec_module(module)
             pluginInfo.module = module
@@ -260,6 +370,7 @@ class PluginSystemManager:
                     attr.__module__ == module.__name__ and
                     hasattr(attr, 'activate')):
                     plugin_class = attr
+                    logger.info(f"Found plugin class: {attr.__name__} in {module_name}")
                     break
 
             if not plugin_class:
@@ -267,32 +378,47 @@ class PluginSystemManager:
                 return False
 
             # Create and initialize plugin instance
+            logger.info(f"Creating instance of plugin class: {plugin_class.__name__}")
             plugin_instance = plugin_class()
             pluginInfo.instance = plugin_instance
 
             # Ensure plugins have a reference to the app
             plugin_instance.app = self.getApp()
+            logger.info(f"Set app reference for plugin: {module_name}")
             
             if hasattr(plugin_instance, 'set_app'):
                 plugin_instance.set_app(self.getApp())
+                logger.info(f"Called set_app() for plugin: {module_name}")
 
             if hasattr(plugin_instance, 'set_plugin_info'):
                 plugin_instance.set_plugin_info(pluginInfo)
+                logger.info(f"Called set_plugin_info() for plugin: {module_name}")
 
             # Register with pluggy and activate
+            if self.plugin_manager is None:
+                logger.error(f"Plugin manager is None when loading {module_name}")
+                return False
+                
+            logger.info(f"Registering plugin with pluggy: {module_name}")
             self.plugin_manager.register(plugin_instance)
+            
             try:
+                logger.info(f"Activating plugin: {module_name}")
                 self.plugin_manager.hook.activate(plugin=plugin_instance)
             except Exception as e:
                 logger.error(f"Error activating plugin {module_name}: {e}")
+                import traceback
+                logger.error(traceback.format_exc())
                 return False
 
             pluginInfo.loaded = True
-            logger.info(f"Loaded plugin: {module_name}")
+            logger.info(f"Successfully loaded plugin: {module_name}")
             return True
 
         except Exception as e:
             logger.error(f"Failed to load plugin {module_name}: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
             return False
 
     def unloadPlugin(self, pluginInfo):

src/cthulhu/plugins/ByeCthulhu/plugin.py

@@ -37,7 +37,8 @@ class ByeCthulhu(Plugin):
             signal_manager = self.app.getSignalManager()
             self._signal_handler_id = signal_manager.connectSignal(
                 "stop-application-completed", 
-                self.process
+                self.process,
+                "default"  # Add profile parameter
             )
         except Exception as e:
             logger.error(f"Error activating ByeCthulhu plugin: {e}")
@@ -54,9 +55,9 @@ class ByeCthulhu(Plugin):
             # Disconnect signal if we have an ID
             if self._signal_handler_id is not None:
                 signal_manager = self.app.getSignalManager()
-                signal_manager.disconnectSignal(
-                    "stop-application-completed",
-                    self._signal_handler_id
+                # Use disconnectSignalByFunction instead since disconnectSignal doesn't exist
+                signal_manager.disconnectSignalByFunction(
+                    self.process
                 )
                 self._signal_handler_id = None
         except Exception as e:

src/cthulhu/plugins/Date/Date.plugin

@@ -1,6 +0,0 @@
-[Plugin]
-Module=Date
-Loader=python3
-Name=Date
-Description=Present the current date
-Authors=Chrys chrys@linux-a11y.org

src/cthulhu/plugins/Date/Date.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-#
-# Copyright (c) 2024 Stormux
-# Copyright (c) 2010-2012 The Orca Team
-# Copyright (c) 2012 Igalia, S.L.
-# Copyright (c) 2005-2010 Sun Microsystems Inc.
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the
-# Free Software Foundation, Inc., Franklin Street, Fifth Floor,
-# Boston MA  02110-1301 USA.
-#
-# Fork of Orca Screen Reader (GNOME)
-# Original source: https://gitlab.gnome.org/GNOME/orca
-
-from cthulhu import plugin
-
-import gi, time
-gi.require_version('Peas', '1.0')
-from gi.repository import GObject
-from gi.repository import Peas
-
-class Date(GObject.Object, Peas.Activatable, plugin.Plugin):
-    #__gtype_name__ = 'Date'
-
-    object = GObject.Property(type=GObject.Object)
-    def __init__(self):
-        plugin.Plugin.__init__(self)
-    def do_activate(self):
-        API = self.object
-        self.connectSignal("setup-inputeventhandlers-completed", self.setupCompatBinding)
-    def setupCompatBinding(self, app):
-        cmdnames = app.getDynamicApiManager().getAPI('Cmdnames')
-        inputEventHandlers = app.getDynamicApiManager().getAPI('inputEventHandlers')
-        inputEventHandlers['presentDateHandler'] = app.getAPIHelper().createInputEventHandler(self.presentDate, cmdnames.PRESENT_CURRENT_DATE)
-    def do_deactivate(self):
-        API = self.object
-        inputEventHandlers = API.app.getDynamicApiManager().getAPI('inputEventHandlers')
-        del inputEventHandlers['presentDateHandler']
-    def presentDate(self, script=None, inputEvent=None):
-        """ Presents the current time. """
-        API = self.object
-        settings_manager = API.app.getDynamicApiManager().getAPI('SettingsManager')
-        _settingsManager = settings_manager.getManager()
-        dateFormat = _settingsManager.getSetting('presentDateFormat')
-        message = time.strftime(dateFormat, time.localtime())
-        API.app.getDynamicApiManager().getAPI('CthulhuState').activeScript.presentMessage(message, resetStyles=False)
-        return True

src/cthulhu/plugins/Date/Makefile.am

@@ -1,7 +0,0 @@
-cthulhu_python_PYTHON = \
-	__init__.py \
-	Date.plugin \
-	Date.py
-
-cthulhu_pythondir=$(pkgpythondir)/plugins/Date
-

src/cthulhu/plugins/Date/__init__.py

@@ -1,25 +0,0 @@
-#!/usr/bin/env python3
-#
-# Copyright (c) 2024 Stormux
-# Copyright (c) 2010-2012 The Orca Team
-# Copyright (c) 2012 Igalia, S.L.
-# Copyright (c) 2005-2010 Sun Microsystems Inc.
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the
-# Free Software Foundation, Inc., Franklin Street, Fifth Floor,
-# Boston MA  02110-1301 USA.
-#
-# Fork of Orca Screen Reader (GNOME)
-# Original source: https://gitlab.gnome.org/GNOME/orca
-

src/cthulhu/plugins/Makefile.am

@@ -1,4 +1,4 @@
-SUBDIRS = Clipboard DisplayVersion hello_world self_voice Time MouseReview Date ByeCthulhu HelloCthulhu PluginManager CapsLockHack SimplePluginSystem
+SUBDIRS = Clipboard DisplayVersion hello_world self_voice Time MouseReview ByeCthulhu HelloCthulhu PluginManager CapsLockHack SimplePluginSystem
 
 cthulhu_pythondir=$(pkgpythondir)/plugins
 

src/cthulhu/settings.py

@@ -413,4 +413,4 @@ presentChatRoomLast = False
 presentLiveRegionFromInactiveTab = False
 
 # Plugins
-activePlugins = ['Clipboard', 'DisplayVersion', 'MouseReview', 'Date', 'ByeCthulhu', 'Time', 'HelloCthulhu', 'hello_world', 'self_voice', 'PluginManager', 'SimplePluginSystem']
+activePlugins = ['Clipboard', 'DisplayVersion', 'MouseReview', 'ByeCthulhu', 'Time', 'HelloCthulhu', 'hello_world', 'self_voice', 'PluginManager', 'SimplePluginSystem']