opencode-semantic-memory 0.4.1__tar.gz → 0.5.1__tar.gz

{opencode_semantic_memory-0.4.1 → opencode_semantic_memory-0.5.1}/.gitignore

@@ -48,3 +48,6 @@ data/
 # OS
 .DS_Store
 Thumbs.db
+
+# Nix
+/result

{opencode_semantic_memory-0.4.1 → opencode_semantic_memory-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-semantic-memory
-Version: 0.4.1
+Version: 0.5.1
 Summary: Persistent semantic memory system for OpenCode sessions
 Author-email: Gregory Havenga <ghavenga@gitlab.com>
 License-Expression: MIT
@@ -57,6 +57,8 @@ opencode-memory is an MCP (Model Context Protocol) server that provides long-ter
 - **Entity tracking**: Links memories to MRs, issues, epics (!123, #456, &789)
 - **GitLab enrichment**: Fetches metadata for entities from GitLab API
 - **Memory age**: All outputs show age to identify potentially outdated information
+- **Proactive context injection**: Automatically injects relevant memories before each LLM call (OpenCode only, via plugin)
+- **Agent-agnostic LLM support**: Works with OpenCode, Claude CLI, GitLab Duo, Ollama, or custom commands
 
 ## Prerequisites
 
@@ -136,6 +138,40 @@ To enable LLM extraction (if you want it), add to `~/.config/opencode-memory/con
 llm_extraction = true
 ```
 
+### LLM Provider Configuration
+
+The memory system supports multiple LLM providers for knowledge extraction and session analysis. By default, it uses OpenCode, but you can configure alternatives:
+
+```toml
+# ~/.config/opencode-memory/config.toml
+
+# Option 1: OpenCode (default) - uses your configured OpenCode LLM
+[llm]
+provider = "opencode"
+
+# Option 2: Anthropic Claude CLI (requires claude-cli package)
+[llm]
+provider = "claude"
+model = "claude-sonnet-4-20250514"  # optional
+
+# Option 3: GitLab Duo CLI (requires glab with Duo enabled)
+[llm]
+provider = "duo"
+
+# Option 4: Ollama (local models)
+[llm]
+provider = "ollama"
+model = "qwen2.5:14b"  # or any model you have pulled
+
+# Option 5: Custom command
+[llm]
+provider = "custom"
+command = "my-llm-cli"
+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.
+
 ## Quick Start
 
 ### 1. Start the Memory Services
@@ -201,7 +237,37 @@ Add to `~/.config/opencode/opencode.json`:
 }
 ```
 
-### 3. Configure the Agent
+### 3. Enable Proactive Context Injection (OpenCode Only)
+
+The proactive context plugin automatically injects relevant memories before each LLM call, so the AI has historical context without needing explicit `memory_recall` calls.
+
+**Requirements:**
+- OpenCode (not supported with other LLM providers)
+- Node.js 20+ (for building the plugin)
+
+**Setup:**
+
+The setup script automatically builds and configures the plugin if Node.js 20+ is available. To verify or configure manually:
+
+```json
+// ~/.config/opencode/opencode.json
+{
+  "mcp": { ... },
+  "plugin": ["/path/to/opencode-memory-install/plugin"]
+}
+```
+
+**How it works:**
+1. User sends a message → Plugin extracts entities (!MR, #issue, @user)
+2. Plugin calls memory server for relevant context
+3. Context is injected into the system prompt before LLM call
+4. AI sees relevant history automatically
+
+**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).
+
+### 4. Configure the Agent
 
 Add to `~/.config/opencode/AGENTS.md`:
 

{opencode_semantic_memory-0.4.1 → opencode_semantic_memory-0.5.1}/README.md

@@ -22,6 +22,8 @@ opencode-memory is an MCP (Model Context Protocol) server that provides long-ter
 - **Entity tracking**: Links memories to MRs, issues, epics (!123, #456, &789)
 - **GitLab enrichment**: Fetches metadata for entities from GitLab API
 - **Memory age**: All outputs show age to identify potentially outdated information
+- **Proactive context injection**: Automatically injects relevant memories before each LLM call (OpenCode only, via plugin)
+- **Agent-agnostic LLM support**: Works with OpenCode, Claude CLI, GitLab Duo, Ollama, or custom commands
 
 ## Prerequisites
 
@@ -101,6 +103,40 @@ To enable LLM extraction (if you want it), add to `~/.config/opencode-memory/con
 llm_extraction = true
 ```
 
+### LLM Provider Configuration
+
+The memory system supports multiple LLM providers for knowledge extraction and session analysis. By default, it uses OpenCode, but you can configure alternatives:
+
+```toml
+# ~/.config/opencode-memory/config.toml
+
+# Option 1: OpenCode (default) - uses your configured OpenCode LLM
+[llm]
+provider = "opencode"
+
+# Option 2: Anthropic Claude CLI (requires claude-cli package)
+[llm]
+provider = "claude"
+model = "claude-sonnet-4-20250514"  # optional
+
+# Option 3: GitLab Duo CLI (requires glab with Duo enabled)
+[llm]
+provider = "duo"
+
+# Option 4: Ollama (local models)
+[llm]
+provider = "ollama"
+model = "qwen2.5:14b"  # or any model you have pulled
+
+# Option 5: Custom command
+[llm]
+provider = "custom"
+command = "my-llm-cli"
+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.
+
 ## Quick Start
 
 ### 1. Start the Memory Services
@@ -166,7 +202,37 @@ Add to `~/.config/opencode/opencode.json`:
 }
 ```
 
-### 3. Configure the Agent
+### 3. Enable Proactive Context Injection (OpenCode Only)
+
+The proactive context plugin automatically injects relevant memories before each LLM call, so the AI has historical context without needing explicit `memory_recall` calls.
+
+**Requirements:**
+- OpenCode (not supported with other LLM providers)
+- Node.js 20+ (for building the plugin)
+
+**Setup:**
+
+The setup script automatically builds and configures the plugin if Node.js 20+ is available. To verify or configure manually:
+
+```json
+// ~/.config/opencode/opencode.json
+{
+  "mcp": { ... },
+  "plugin": ["/path/to/opencode-memory-install/plugin"]
+}
+```
+
+**How it works:**
+1. User sends a message → Plugin extracts entities (!MR, #issue, @user)
+2. Plugin calls memory server for relevant context
+3. Context is injected into the system prompt before LLM call
+4. AI sees relevant history automatically
+
+**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).
+
+### 4. Configure the Agent
 
 Add to `~/.config/opencode/AGENTS.md`:
 

opencode_semantic_memory-0.5.1/flake.nix

@@ -0,0 +1,93 @@
+{
+  description = "Persistent semantic memory system for OpenCode sessions";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+  };
+
+  outputs =
+    { self, nixpkgs }:
+    let
+      eachSystem = nixpkgs.lib.genAttrs [
+        "aarch64-darwin"
+        "aarch64-linux"
+        "x86_64-darwin"
+        "x86_64-linux"
+      ];
+    in
+    {
+      packages = eachSystem (
+        system:
+        let
+          pkgs = nixpkgs.legacyPackages.${system};
+          inherit (nixpkgs) lib;
+
+          # On Darwin, every tree-sitter-grammars.* python package ships a
+          # `parser` shared object whose install-name is the bare string
+          # "parser". When more than one is loaded into the same process
+          # (our code imports python+javascript+ruby grammars together),
+          # dyld treats them as the same library and the first-loaded one
+          # wins. The other grammars' _binding.so files then fail to find
+          # their language symbols against the wrong parser.
+          #
+          # Fix: rewrite each grammar's _binding.so to reference its own
+          # parser by absolute path instead of the bare "parser" install-
+          # name, so dyld looks up each one independently.
+          fixTreeSitterGrammar =
+            drv:
+            drv.overrideAttrs (old: {
+              postFixup =
+                (old.postFixup or "")
+                + lib.optionalString pkgs.stdenv.hostPlatform.isDarwin ''
+                  for binding in "$out"/lib/python*/site-packages/*/_binding.*.so; do
+                    [ -e "$binding" ] || continue
+                    pkgdir=$(dirname "$binding")
+                    grammar_parser=$(sed -n 's/^parser = "\([^"]*\)".*/\1/p' "$pkgdir/__init__.py")
+                    [ -n "$grammar_parser" ] || continue
+                    chmod +w "$binding"
+                    ${pkgs.darwin.cctools}/bin/install_name_tool \
+                      -change parser "$grammar_parser" "$binding"
+                  done
+                '';
+            });
+
+          python3 = pkgs.python3.override {
+            self = python3;
+            packageOverrides = pyfinal: pyprev: {
+              pysnooper = pyprev.pysnooper.overridePythonAttrs (old: {
+                disabledTests =
+                  (old.disabledTests or [ ])
+                  ++ lib.optionals pkgs.stdenv.hostPlatform.isDarwin [
+                    "test_relative_time"
+                  ];
+              });
+
+              tree-sitter-grammars = pyprev.tree-sitter-grammars // {
+                tree-sitter-python = fixTreeSitterGrammar pyprev.tree-sitter-grammars.tree-sitter-python;
+                tree-sitter-javascript = fixTreeSitterGrammar pyprev.tree-sitter-grammars.tree-sitter-javascript;
+                tree-sitter-ruby = fixTreeSitterGrammar pyprev.tree-sitter-grammars.tree-sitter-ruby;
+              };
+            };
+          };
+        in
+        {
+          default = pkgs.callPackage ./nix/package.nix {
+            src = self;
+            python3Packages = python3.pkgs;
+          };
+          model = pkgs.callPackage ./nix/model.nix { };
+        }
+      );
+
+      darwinModules = {
+        default = self.darwinModules.opencode-memory;
+        opencode-memory =
+          { pkgs, ... }:
+          {
+            imports = [ ./nix/module.nix ];
+            services.opencode-memory.package = self.packages.${pkgs.stdenv.hostPlatform.system}.default;
+            services.opencode-memory.model = self.packages.${pkgs.stdenv.hostPlatform.system}.model;
+          };
+      };
+    };
+}

{opencode_semantic_memory-0.4.1 → opencode_semantic_memory-0.5.1}/nix/package.nix

@@ -23,6 +23,10 @@ python3Packages.buildPythonApplication {
     starlette
     uvicorn
     pylance # for vector cleanup
+    tree-sitter
+    tree-sitter-grammars.tree-sitter-python
+    tree-sitter-grammars.tree-sitter-javascript
+    tree-sitter-grammars.tree-sitter-ruby
   ];
 
   pythonImportsCheck = [ "opencode_memory" ];

{opencode_semantic_memory-0.4.1 → opencode_semantic_memory-0.5.1}/plugin/src/index.ts

@@ -33,6 +33,9 @@ const sessionContextCache = new Map<string, ProactiveContextResponse | null>();
 // Track memory IDs already injected per session to avoid redundant injection
 const injectedMemoryIds = new Map<string, Set<number>>();
 
+// Track turn numbers per session for injection logging
+const sessionTurnNumbers = new Map<string, number>();
+
 // Memory client instance (lazy initialized)
 let memoryClient: MemoryClient | null = null;
 
@@ -197,11 +200,28 @@ export const server: Plugin = async (input, _options) => {
         return;
       }
 
+      // Increment turn number for this session
+      const turnNumber = (sessionTurnNumbers.get(sessionID) ?? 0) + 1;
+      sessionTurnNumbers.set(sessionID, turnNumber);
+
       // Format and append to system prompt
       const contextSection = formatContextForSystem(context);
       
       if (contextSection) {
         output.system.push(contextSection);
+        
+        // Log the injection for effectiveness tracking (fire and forget)
+        client.logInjection({
+          sessionId: sessionID,
+          turnNumber,
+          memoryIds: context.items.map(item => item.memory_id),
+          relevanceSummary: context.relevance_summary,
+          queryPreview: context.semantic_query,
+          totalTokens: context.total_tokens,
+          itemsCount: context.items_count,
+        }).catch(() => { /* silent */ });
+        
+        debugLog(`[system.transform] logged injection: turn=${turnNumber} items=${context.items_count}`);
       }
     },
   };

{opencode_semantic_memory-0.4.1 → opencode_semantic_memory-0.5.1}/plugin/src/memory-client.ts

@@ -146,6 +146,42 @@ export class MemoryClient {
       clearTimeout(timeoutId);
     }
   }
+
+  async logInjection(params: LogInjectionParams): 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}/log-injection`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          session_id: params.sessionId,
+          turn_number: params.turnNumber,
+          memory_ids: params.memoryIds,
+          relevance_summary: params.relevanceSummary,
+          query_preview: params.queryPreview,
+          total_tokens: params.totalTokens,
+          items_count: params.itemsCount,
+        }),
+        signal: controller.signal,
+      });
+      // Ignore response - fire and forget
+    } catch {
+      // Silent failure - logging shouldn't break the plugin
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
 }
 
 export interface WorkspaceInitResponse {
@@ -162,3 +198,13 @@ export interface WorkspaceInitResponse {
   total_facts_created?: number;
   error?: string;
 }
+
+export interface LogInjectionParams {
+  sessionId: string;
+  turnNumber: number;
+  memoryIds: number[];
+  relevanceSummary?: string;
+  queryPreview?: string;
+  totalTokens?: number;
+  itemsCount?: number;
+}

{opencode_semantic_memory-0.4.1 → opencode_semantic_memory-0.5.1}/pyproject.toml

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