opencode-semantic-memory 0.8.0__tar.gz → 0.8.2__tar.gz

{opencode_semantic_memory-0.8.0 → opencode_semantic_memory-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-semantic-memory
-Version: 0.8.0
+Version: 0.8.2
 Summary: Persistent semantic memory system for OpenCode sessions
 Author-email: Gregory Havenga <ghavenga@gitlab.com>
 License-Expression: MIT
@@ -172,6 +172,41 @@ args = ["--prompt"]  # prompt is appended after these args
 
 **Note:** The proactive context injection feature (automatic memory loading) currently only works with OpenCode via the plugin system. Other LLM providers can still use all memory tools manually.
 
+## Updating
+
+To update an existing installation, re-run the quick install script. It is idempotent and will pull the latest code, refresh dependencies, and restart the background services:
+
+```bash
+curl -fsSL https://gitlab.com/ghavenga/opencode-memory/-/raw/master/scripts/setup.sh | bash
+```
+
+The update is **non-destructive** for your data:
+
+- Your memory database at `~/.local/share/opencode-memory/memory.db` is not touched
+- Your vector store at `~/.local/share/opencode-memory/vectors/` is not touched
+- Your existing `~/.config/opencode-memory/config.toml` is preserved (the script only writes a default if one does not already exist)
+
+The script's `rm -rf` operations are scoped to the install directory (`~/.local/share/opencode-memory-install`) and only trigger when the git checkout or virtual environment is in a broken state. Any uncommitted local changes inside the install directory will be discarded (`git reset --hard` + `git clean -fd`) before the pull.
+
+If you want to be extra cautious before a major update, snapshot the data directory first:
+
+```bash
+# Consistent SQLite backup (handles WAL files correctly)
+TS=$(date +%Y%m%d-%H%M%S)
+BACKUP_DIR="$HOME/.local/share/opencode-memory-backups/$TS"
+mkdir -p "$BACKUP_DIR"
+sqlite3 "$HOME/.local/share/opencode-memory/memory.db" ".backup '$BACKUP_DIR/memory.db'"
+cp -R "$HOME/.local/share/opencode-memory/vectors" "$BACKUP_DIR/vectors"
+cp "$HOME/.config/opencode-memory/config.toml" "$BACKUP_DIR/config.toml"
+```
+
+After the update, verify the service is healthy:
+
+```bash
+curl -s http://127.0.0.1:9824/health
+# {"status":"ok","server":"opencode-memory","daemon":{"running":true}}
+```
+
 ## Quick Start
 
 ### 1. Start the Memory Services
@@ -263,6 +298,10 @@ The setup script automatically builds and configures the plugin if Node.js 20+ i
 3. Context is injected into the system prompt before LLM call
 4. AI sees relevant history automatically
 
+**Thinking-aware injection:** The plugin also analyzes the assistant's responses to inject context mid-conversation. If the AI is "thinking" about a topic it has prior knowledge of, relevant memories are injected before the next LLM call.
+
+**Relevance filtering:** Items with semantic similarity below 0.35 are filtered out to reduce noise. This threshold was tuned based on effectiveness analysis showing low-relevance items had 0% actual usefulness.
+
 **Note:** If you're using a different LLM provider (Claude, Duo, Ollama), you'll need to call memory tools explicitly - proactive injection only works with the OpenCode plugin.
 
 For more details, see the [plugin documentation](plugin/README.md).
@@ -412,7 +451,8 @@ Work item queue for tracking todos, MRs to review, and authored MRs. Supports P0
 
 | Tool | Description |
 |------|-------------|
-| `memory_effectiveness_report(days?)` | Memory usage patterns and suggestions |
+| `memory_effectiveness_report(days?)` | Memory usage patterns, injection effectiveness, and suggestions |
+| `memory_injection_metrics_trend(days?)` | Daily injection metrics over time for tracking improvements |
 | `memory_background_report(days?)` | Background process activity |
 | `memory_tool_metrics(action?, since_hours?)` | MCP tool call timing metrics |
 | `memory_vector_index(action?)` | Manage vector search index |

{opencode_semantic_memory-0.8.0 → opencode_semantic_memory-0.8.2}/README.md

@@ -137,6 +137,41 @@ args = ["--prompt"]  # prompt is appended after these args
 
 **Note:** The proactive context injection feature (automatic memory loading) currently only works with OpenCode via the plugin system. Other LLM providers can still use all memory tools manually.
 
+## Updating
+
+To update an existing installation, re-run the quick install script. It is idempotent and will pull the latest code, refresh dependencies, and restart the background services:
+
+```bash
+curl -fsSL https://gitlab.com/ghavenga/opencode-memory/-/raw/master/scripts/setup.sh | bash
+```
+
+The update is **non-destructive** for your data:
+
+- Your memory database at `~/.local/share/opencode-memory/memory.db` is not touched
+- Your vector store at `~/.local/share/opencode-memory/vectors/` is not touched
+- Your existing `~/.config/opencode-memory/config.toml` is preserved (the script only writes a default if one does not already exist)
+
+The script's `rm -rf` operations are scoped to the install directory (`~/.local/share/opencode-memory-install`) and only trigger when the git checkout or virtual environment is in a broken state. Any uncommitted local changes inside the install directory will be discarded (`git reset --hard` + `git clean -fd`) before the pull.
+
+If you want to be extra cautious before a major update, snapshot the data directory first:
+
+```bash
+# Consistent SQLite backup (handles WAL files correctly)
+TS=$(date +%Y%m%d-%H%M%S)
+BACKUP_DIR="$HOME/.local/share/opencode-memory-backups/$TS"
+mkdir -p "$BACKUP_DIR"
+sqlite3 "$HOME/.local/share/opencode-memory/memory.db" ".backup '$BACKUP_DIR/memory.db'"
+cp -R "$HOME/.local/share/opencode-memory/vectors" "$BACKUP_DIR/vectors"
+cp "$HOME/.config/opencode-memory/config.toml" "$BACKUP_DIR/config.toml"
+```
+
+After the update, verify the service is healthy:
+
+```bash
+curl -s http://127.0.0.1:9824/health
+# {"status":"ok","server":"opencode-memory","daemon":{"running":true}}
+```
+
 ## Quick Start
 
 ### 1. Start the Memory Services
@@ -228,6 +263,10 @@ The setup script automatically builds and configures the plugin if Node.js 20+ i
 3. Context is injected into the system prompt before LLM call
 4. AI sees relevant history automatically
 
+**Thinking-aware injection:** The plugin also analyzes the assistant's responses to inject context mid-conversation. If the AI is "thinking" about a topic it has prior knowledge of, relevant memories are injected before the next LLM call.
+
+**Relevance filtering:** Items with semantic similarity below 0.35 are filtered out to reduce noise. This threshold was tuned based on effectiveness analysis showing low-relevance items had 0% actual usefulness.
+
 **Note:** If you're using a different LLM provider (Claude, Duo, Ollama), you'll need to call memory tools explicitly - proactive injection only works with the OpenCode plugin.
 
 For more details, see the [plugin documentation](plugin/README.md).
@@ -377,7 +416,8 @@ Work item queue for tracking todos, MRs to review, and authored MRs. Supports P0
 
 | Tool | Description |
 |------|-------------|
-| `memory_effectiveness_report(days?)` | Memory usage patterns and suggestions |
+| `memory_effectiveness_report(days?)` | Memory usage patterns, injection effectiveness, and suggestions |
+| `memory_injection_metrics_trend(days?)` | Daily injection metrics over time for tracking improvements |
 | `memory_background_report(days?)` | Background process activity |
 | `memory_tool_metrics(action?, since_hours?)` | MCP tool call timing metrics |
 | `memory_vector_index(action?)` | Manage vector search index |

{opencode_semantic_memory-0.8.0 → opencode_semantic_memory-0.8.2}/plugin/src/index.ts

@@ -225,6 +225,18 @@ export const server: Plugin = async (input, _options) => {
           for (const item of context.items) {
             sessionIds.add(item.memory_id);
           }
+          
+          // Log user query injection for effectiveness tracking (fire-and-forget)
+          client.logContextEvent({
+            sessionId: sessionID,
+            eventType: 'user_injection',
+            memoryIds: context.items.map((item: { memory_id: number }) => item.memory_id),
+            source: 'user_query',
+            triggerText: userText.slice(0, 500),  // Truncate long queries
+            relevanceScore: context.relevance_summary,
+            query: context.semantic_query,
+            tokens: context.total_tokens,
+          }).catch(() => { /* silent */ });
         }
 
         // Cache proactive context for system.transform hook
@@ -484,6 +496,7 @@ export const server: Plugin = async (input, _options) => {
       // Inject thinking-based context (from semantic analysis of assistant's last response)
       // This enables proactive injection based on what the assistant is thinking about
       const thinkingContext = sessionThinkingContext.get('_last') ?? sessionThinkingContext.get(sessionID);
+      const thinkingTrigger = lastAssistantThinking.get('_last') ?? lastAssistantThinking.get(sessionID);
       if (thinkingContext && thinkingContext.items && thinkingContext.items.length > 0) {
         // Filter out items already injected in this session
         const sessionIds = injectedMemoryIds.get(sessionID) ?? new Set<number>();
@@ -505,11 +518,25 @@ export const server: Plugin = async (input, _options) => {
           for (const item of newItems) {
             updatedSessionIds.add(item.memory_id);
           }
+          
+          // Log the context event for effectiveness tracking (fire-and-forget)
+          client.logContextEvent({
+            sessionId: sessionID,
+            eventType: 'thinking_injection',
+            memoryIds: newItems.map(item => item.memory_id),
+            source: 'thinking',
+            triggerText: thinkingTrigger ?? undefined,
+            relevanceScore: thinkingContext.relevance_summary,
+            query: thinkingContext.semantic_query,
+            tokens: thinkingContext.total_tokens,
+          }).catch(() => { /* silent */ });
         }
         
         // Clear thinking context after injection (one-shot)
         sessionThinkingContext.delete('_last');
         sessionThinkingContext.delete(sessionID);
+        lastAssistantThinking.delete('_last');
+        lastAssistantThinking.delete(sessionID);
       }
     },
   };

{opencode_semantic_memory-0.8.0 → opencode_semantic_memory-0.8.2}/plugin/src/memory-client.ts

@@ -324,6 +324,48 @@ export class MemoryClient {
       clearTimeout(timeoutId);
     }
   }
+
+  /**
+   * Log a context event for effectiveness tracking.
+   * Supports both user-triggered and thinking-triggered injections.
+   */
+  async logContextEvent(params: LogContextEventParams): Promise<void> {
+    // Fire and forget - don't block on logging
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 2000);
+
+    try {
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+      };
+      
+      if (this.apiKey) {
+        headers['Authorization'] = `Bearer ${this.apiKey}`;
+      }
+
+      await fetch(`${this.baseUrl}/context-event`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          session_id: params.sessionId,
+          event_type: params.eventType,
+          memory_ids: params.memoryIds,
+          source: params.source,
+          trigger_text: params.triggerText,
+          relevance_score: params.relevanceScore,
+          query: params.query,
+          turn_number: params.turnNumber,
+          tokens: params.tokens,
+        }),
+        signal: controller.signal,
+      });
+      // Ignore response - fire and forget
+    } catch {
+      // Silent failure - logging shouldn't break the plugin
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
 }
 
 export interface WorkspaceInitResponse {
@@ -351,6 +393,18 @@ export interface LogInjectionParams {
   itemsCount?: number;
 }
 
+export interface LogContextEventParams {
+  sessionId: string;
+  eventType: 'injection' | 'thinking_injection' | 'user_injection' | 'boot' | 'recall';
+  memoryIds: number[];
+  source?: 'user' | 'user_query' | 'thinking' | 'boot' | 'explicit';
+  triggerText?: string;
+  relevanceScore?: string;
+  query?: string;
+  turnNumber?: number;
+  tokens?: number;
+}
+
 export interface BootContextIdsResponse {
   memory_ids: number[];
 }

{opencode_semantic_memory-0.8.0 → opencode_semantic_memory-0.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "opencode-semantic-memory"
-version = "0.8.0"
+version = "0.8.2"
 description = "Persistent semantic memory system for OpenCode sessions"
 readme = "README.md"
 license = "MIT"