feat(perf): implement global singleton pattern and plugin warmup optimization

Refactor plugin initialization to use global singletons and move warmup logic
to plugin startup instead of per-session. This eliminates redundant model
loading and improves first-message response time significantly.

Key changes:
- Add global singleton pattern for EmbeddingService using Symbol-based keys
- Move warmup logic from message handler to plugin initialization
- Add global warmup state tracking to prevent re-initialization
- Refactor logger to use lazy initialization with global state flag
- Extract embedding initialization into separate private method

This resolves performance issues where the memory system would reinitialize
on every session start, causing 30-60s delays for first-time users.

Author: tickernelz

package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-mem",
-  "version": "2.3.3",
+  "version": "2.3.4",
   "description": "OpenCode plugin that gives coding agents persistent memory using local vector database",
   "type": "module",
   "main": "dist/plugin.js",

src/index.ts

@@ -50,6 +50,18 @@ export const OpenCodeMemPlugin: Plugin = async (ctx: PluginInput) => {
     log("Plugin disabled - memory system not configured");
   }
 
+  const GLOBAL_PLUGIN_WARMUP_KEY = Symbol.for("opencode-mem.plugin.warmedup");
+
+  if (!(globalThis as any)[GLOBAL_PLUGIN_WARMUP_KEY] && isConfigured()) {
+    try {
+      await memoryClient.warmup();
+      (globalThis as any)[GLOBAL_PLUGIN_WARMUP_KEY] = true;
+      log("Plugin warmup completed");
+    } catch (error) {
+      log("Plugin warmup failed", { error: String(error) });
+    }
+  }
+
   if (CONFIG.webServerEnabled) {
     startWebServer({
       port: CONFIG.webServerPort,
@@ -158,65 +170,6 @@ export const OpenCodeMemPlugin: Plugin = async (ctx: PluginInput) => {
         if (isFirstMessage) {
           injectedSessions.add(input.sessionID);
 
-          const needsWarmup = !(await memoryClient.isReady());
-
-          if (needsWarmup) {
-            if (ctx.client?.tui) {
-              await ctx.client.tui
-                .showToast({
-                  body: {
-                    title: "Memory System",
-                    message: "Initializing (first time: 30-60s)...",
-                    variant: "info",
-                    duration: 5000,
-                  },
-                })
-                .catch(() => {});
-            }
-
-            try {
-              await memoryClient.warmup();
-
-              if (ctx.client?.tui) {
-                const autoCaptureStatus =
-                  CONFIG.autoCaptureEnabled &&
-                  CONFIG.memoryModel &&
-                  CONFIG.memoryApiUrl &&
-                  CONFIG.memoryApiKey
-                    ? "Auto-capture: enabled"
-                    : "Auto-capture: disabled";
-
-                await ctx.client.tui
-                  .showToast({
-                    body: {
-                      title: "Memory System Ready!",
-                      message: autoCaptureStatus,
-                      variant: CONFIG.autoCaptureEnabled ? "success" : "warning",
-                      duration: 3000,
-                    },
-                  })
-                  .catch(() => {});
-              }
-            } catch (warmupError) {
-              log("Warmup failed", { error: String(warmupError) });
-
-              if (ctx.client?.tui) {
-                await ctx.client.tui
-                  .showToast({
-                    body: {
-                      title: "Memory System Error",
-                      message: `Failed to initialize: ${String(warmupError)}`,
-                      variant: "error",
-                      duration: 10000,
-                    },
-                  })
-                  .catch(() => {});
-              }
-
-              return;
-            }
-          }
-
           const projectMemoriesListResult = await memoryClient.listMemories(
             tags.project.tag,
             CONFIG.maxMemories

src/services/embedding.ts

@@ -7,6 +7,7 @@ env.allowRemoteModels = true;
 env.cacheDir = CONFIG.storagePath + "/.cache";
 
 const TIMEOUT_MS = 30000;
+const GLOBAL_EMBEDDING_KEY = Symbol.for("opencode-mem.embedding.instance");
 
 function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
   return Promise.race([
@@ -20,34 +21,42 @@ export class EmbeddingService {
   private initPromise: Promise<void> | null = null;
   public isWarmedUp: boolean = false;
 
+  static getInstance(): EmbeddingService {
+    if (!(globalThis as any)[GLOBAL_EMBEDDING_KEY]) {
+      (globalThis as any)[GLOBAL_EMBEDDING_KEY] = new EmbeddingService();
+    }
+    return (globalThis as any)[GLOBAL_EMBEDDING_KEY];
+  }
+
   async warmup(progressCallback?: (progress: any) => void): Promise<void> {
     if (this.isWarmedUp) return;
     if (this.initPromise) return this.initPromise;
 
-    this.initPromise = (async () => {
-      try {
-        if (CONFIG.embeddingApiUrl && CONFIG.embeddingApiKey) {
-          log("Using OpenAI-compatible API for embeddings");
-          this.isWarmedUp = true;
-          return;
-        }
-
-        log("Downloading embedding model", { model: CONFIG.embeddingModel });
-
-        this.pipe = await pipeline("feature-extraction", CONFIG.embeddingModel, {
-          progress_callback: progressCallback,
-        });
+    this.initPromise = this.initializeModel(progressCallback);
+    return this.initPromise;
+  }
 
+  private async initializeModel(progressCallback?: (progress: any) => void): Promise<void> {
+    try {
+      if (CONFIG.embeddingApiUrl && CONFIG.embeddingApiKey) {
+        log("Using OpenAI-compatible API for embeddings");
         this.isWarmedUp = true;
-        log("Embedding model ready");
-      } catch (error) {
-        this.initPromise = null;
-        log("Failed to initialize embedding model", { error: String(error) });
-        throw error;
+        return;
       }
-    })();
 
-    return this.initPromise;
+      log("Downloading embedding model", { model: CONFIG.embeddingModel });
+
+      this.pipe = await pipeline("feature-extraction", CONFIG.embeddingModel, {
+        progress_callback: progressCallback,
+      });
+
+      this.isWarmedUp = true;
+      log("Embedding model ready");
+    } catch (error) {
+      this.initPromise = null;
+      log("Failed to initialize embedding model", { error: String(error) });
+      throw error;
+    }
   }
 
   async embed(text: string): Promise<Float32Array> {
@@ -89,4 +98,4 @@ export class EmbeddingService {
   }
 }
 
-export const embeddingService = new EmbeddingService();
+export const embeddingService = EmbeddingService.getInstance();

src/services/logger.ts

@@ -5,13 +5,19 @@ import { join } from "path";
 const LOG_DIR = join(homedir(), ".opencode-mem");
 const LOG_FILE = join(LOG_DIR, "opencode-mem.log");
 
-if (!existsSync(LOG_DIR)) {
-  mkdirSync(LOG_DIR, { recursive: true });
-}
+const GLOBAL_LOGGER_KEY = Symbol.for("opencode-mem.logger.initialized");
 
-writeFileSync(LOG_FILE, `\n--- Session started: ${new Date().toISOString()} ---\n`, { flag: "a" });
+function ensureLoggerInitialized() {
+  if ((globalThis as any)[GLOBAL_LOGGER_KEY]) return;
+  if (!existsSync(LOG_DIR)) {
+    mkdirSync(LOG_DIR, { recursive: true });
+  }
+  writeFileSync(LOG_FILE, `\n--- Session started: ${new Date().toISOString()} ---\n`, { flag: "a" });
+  (globalThis as any)[GLOBAL_LOGGER_KEY] = true;
+}
 
 export function log(message: string, data?: unknown) {
+  ensureLoggerInitialized();
   const timestamp = new Date().toISOString();
   const line = data
     ? `[${timestamp}] ${message}: ${JSON.stringify(data)}\n`