feat(kernel): Enhance plugin loader with context management and synchronous service retrieval

Author: hotlong

packages/core/src/kernel.ts

@@ -81,7 +81,15 @@ export class ObjectKernel {
                     return service as T;
                 }
 
-                // 2. Try to get from plugin loader (supports factories and lifecycle)
+                // 2. Try to get from plugin loader cache (Sync access to factories)
+                const loaderService = this.pluginLoader.getServiceInstance<T>(name);
+                if (loaderService) {
+                    // Cache it locally for faster next access
+                    this.services.set(name, loaderService);
+                    return loaderService;
+                }
+
+                // 3. Try to get from plugin loader (support async factories)
                 try {
                     const service = this.pluginLoader.getService(name);
                     if (service instanceof Promise) {
@@ -116,6 +124,8 @@ export class ObjectKernel {
             getKernel: () => this as any, // Type compatibility
         };
 
+        this.pluginLoader.setContext(this.context);
+
         // Register shutdown handler
         if (this.config.gracefulShutdown) {
             this.registerShutdownSignals();

packages/core/src/plugin-loader.test.ts

@@ -1,14 +1,23 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { PluginLoader, ServiceLifecycle, PluginMetadata } from './plugin-loader';
 import { createLogger } from './logger';
-import type { Plugin } from './types';
+import type { Plugin, PluginContext } from './types';
 
 describe('PluginLoader', () => {
     let loader: PluginLoader;
 
     beforeEach(() => {
         const logger = createLogger({ level: 'error' }); // Suppress logs in tests
         loader = new PluginLoader(logger);
+        loader.setContext({
+            registerService: () => {},
+            getService: () => { throw new Error('Mock service not found'); },
+            hook: () => {},
+            trigger: async () => {},
+            getServices: () => new Map(),
+            logger: logger,
+            getKernel: () => ({}) as any
+        } as PluginContext);
     });
 
     describe('Plugin Loading', () => {

packages/core/src/plugin-loader.ts

@@ -111,6 +111,7 @@ export interface VersionCompatibility {
  */
 export class PluginLoader {
     private logger: Logger;
+    private context?: PluginContext;
     private loadedPlugins: Map<string, PluginMetadata> = new Map();
     private serviceFactories: Map<string, ServiceRegistration> = new Map();
     private serviceInstances: Map<string, any> = new Map();
@@ -120,6 +121,20 @@ export class PluginLoader {
         this.logger = logger;
     }
 
+    /**
+     * Set the plugin context for service factories
+     */
+    setContext(context: PluginContext): void {
+        this.context = context;
+    }
+
+    /**
+     * Get a synchronous service instance if it exists (Sync Helper)
+     */
+    getServiceInstance<T>(name: string): T | undefined {
+        return this.serviceInstances.get(name) as T;
+    }
+
     /**
      * Load a plugin asynchronously with validation
      */
@@ -431,9 +446,9 @@ export class PluginLoader {
     }
 
     private async createServiceInstance(registration: ServiceRegistration): Promise<any> {
-        // This is a simplified version - in real implementation,
-        // we would need to pass proper context with resolved dependencies
-        const mockContext = {} as PluginContext;
-        return await registration.factory(mockContext);
+        if (!this.context) {
+            throw new Error(`[PluginLoader] Context not set - cannot create service '${registration.name}'`);
+        }
+        return await registration.factory(this.context);
     }
 }