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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-semantic-memory
-Version: 0.4.1
+Version: 0.5.0
 Summary: Persistent semantic memory system for OpenCode sessions
 Author-email: Gregory Havenga <ghavenga@gitlab.com>
 License-Expression: MIT

opencode_semantic_memory-0.5.0/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.0}/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.0}/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.0}/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.0}/pyproject.toml

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

{opencode_semantic_memory-0.4.1 → opencode_semantic_memory-0.5.0}/scripts/setup.sh

@@ -794,6 +794,99 @@ EOF
     echo "  tail -f $LOG_DIR/worker.log      # View worker logs"
 }
 
+# Configure OpenCode permissions for memory tools
+configure_opencode_permissions() {
+    local OPENCODE_CONFIG="$HOME/.config/opencode/opencode.json"
+    
+    # Check if permissions are already set for memory tools
+    if [[ -f "$OPENCODE_CONFIG" ]]; then
+        if grep -q '"memory_\*"' "$OPENCODE_CONFIG" 2>/dev/null || \
+           grep -q '"memory_get_boot_context"' "$OPENCODE_CONFIG" 2>/dev/null; then
+            info "Memory tool permissions already configured"
+            return 0
+        fi
+    fi
+    
+    echo ""
+    echo -e "${YELLOW}OpenCode Permission Setup${NC}"
+    echo ""
+    echo "The memory system requires permission to run memory_* tools."
+    echo "Without this, OpenCode will prompt for approval on each memory call."
+    echo ""
+    echo "Options:"
+    echo "  1. Allow all memory tools automatically (recommended)"
+    echo "  2. Allow only memory_get_boot_context (minimal)"
+    echo "  3. Skip - configure manually later"
+    echo ""
+    
+    local choice
+    if [ -t 0 ]; then
+        read -p "Choice [1/2/3] (default: 1): " -n 1 -r choice
+        echo ""
+    else
+        # Non-interactive - skip permission changes (require explicit consent)
+        info "Non-interactive mode: skipping permission setup (requires explicit consent)"
+        info "Run interactively or add manually: \"permission\": { \"memory_*\": \"allow\" }"
+        return 0
+    fi
+    
+    # Default to option 1 if empty
+    choice="${choice:-1}"
+    
+    case "$choice" in
+        1)
+            local perm_pattern='"memory_*": "allow"'
+            info "Configuring: allow all memory_* tools"
+            ;;
+        2)
+            local perm_pattern='"memory_get_boot_context": "allow"'
+            info "Configuring: allow memory_get_boot_context only"
+            ;;
+        3|*)
+            info "Skipping permission setup"
+            echo "Add manually to ~/.config/opencode/opencode.json:"
+            echo '  "permission": { "memory_*": "allow" }'
+            return 0
+            ;;
+    esac
+    
+    mkdir -p "$(dirname "$OPENCODE_CONFIG")"
+    
+    if [[ -f "$OPENCODE_CONFIG" ]]; then
+        # Config exists - try to add permission
+        if command -v jq >/dev/null 2>&1; then
+            local tmp_file=$(mktemp)
+            if [[ "$choice" == "1" ]]; then
+                if jq '.permission["memory_*"] = "allow"' "$OPENCODE_CONFIG" > "$tmp_file" 2>/dev/null; then
+                    mv "$tmp_file" "$OPENCODE_CONFIG"
+                    info "Memory tool permissions added"
+                else
+                    rm -f "$tmp_file"
+                    warn "Could not auto-update permissions. Add manually:"
+                    echo '  "permission": { "memory_*": "allow" }'
+                fi
+            else
+                if jq '.permission["memory_get_boot_context"] = "allow"' "$OPENCODE_CONFIG" > "$tmp_file" 2>/dev/null; then
+                    mv "$tmp_file" "$OPENCODE_CONFIG"
+                    info "Memory tool permission added"
+                else
+                    rm -f "$tmp_file"
+                    warn "Could not auto-update permissions. Add manually:"
+                    echo '  "permission": { "memory_get_boot_context": "allow" }'
+                fi
+            fi
+        else
+            warn "jq not installed - cannot auto-update config"
+            warn "Add manually to $OPENCODE_CONFIG:"
+            echo "  \"permission\": { $perm_pattern }"
+        fi
+    else
+        # Will be created by configure_opencode() - just note we need to add permissions
+        # Store choice for configure_opencode to use
+        export MEMORY_PERMISSION_CHOICE="$choice"
+    fi
+}
+
 # Configure OpenCode
 configure_opencode() {
     local OPENCODE_CONFIG="$HOME/.config/opencode/opencode.json"
@@ -868,8 +961,33 @@ configure_opencode() {
         fi
     else
         info "Creating OpenCode configuration..."
+        
+        # Determine permission setting based on earlier choice
+        local perm_setting=""
+        case "${MEMORY_PERMISSION_CHOICE:-1}" in
+            1) perm_setting='"memory_*": "allow"' ;;
+            2) perm_setting='"memory_get_boot_context": "allow"' ;;
+            *) perm_setting="" ;;
+        esac
+        
         if [[ "$PLUGIN_BUILT" == true ]]; then
-            cat > "$OPENCODE_CONFIG" << EOF
+            if [[ -n "$perm_setting" ]]; then
+                cat > "$OPENCODE_CONFIG" << EOF
+{
+  "mcp": {
+    "memory": {
+      "type": "remote",
+      "url": "http://localhost:9824/mcp"
+    }
+  },
+  "permission": {
+    $perm_setting
+  },
+  "plugin": ["$INSTALL_DIR/plugin"]
+}
+EOF
+            else
+                cat > "$OPENCODE_CONFIG" << EOF
 {
   "mcp": {
     "memory": {
@@ -880,8 +998,24 @@ configure_opencode() {
   "plugin": ["$INSTALL_DIR/plugin"]
 }
 EOF
+            fi
         else
-            cat > "$OPENCODE_CONFIG" << 'EOF'
+            if [[ -n "$perm_setting" ]]; then
+                cat > "$OPENCODE_CONFIG" << EOF
+{
+  "mcp": {
+    "memory": {
+      "type": "remote",
+      "url": "http://localhost:9824/mcp"
+    }
+  },
+  "permission": {
+    $perm_setting
+  }
+}
+EOF
+            else
+                cat > "$OPENCODE_CONFIG" << 'EOF'
 {
   "mcp": {
     "memory": {
@@ -891,6 +1025,7 @@ EOF
   }
 }
 EOF
+            fi
         fi
     fi
 }
@@ -1066,6 +1201,7 @@ elif [[ "$OS_TYPE" == "macos" ]]; then
     setup_macos_service
 fi
 
+configure_opencode_permissions
 configure_opencode
 setup_agents_md
 

opencode_semantic_memory-0.5.0/slack-post-memory-effectiveness.md

@@ -0,0 +1,23 @@
+## Memory System Self-Analysis: Measuring AI Forgetfulness
+
+Built an introspection system for my OpenCode memory module that analyzes past sessions to detect "missed opportunities" - moments where memory should have helped but didn't.
+
+**How it works:** A background worker sends session conversations to an OpenCode subagent that looks for patterns like user corrections (*"I told you last week..."*), repeated explanations, and skipped startup rituals. It includes actual tool calls in the analysis so it can distinguish "AI said it would check memory" vs "AI actually did."
+
+**What we found** (1,664 sessions, Jan-May):
+
+```
+Week     | Misses/Session
+---------|---------------
+Jan W03  |     1.13
+Jan W04  |     1.14
+Apr W16  |     1.27
+May W18  |     0.06
+May W19  |     0.01
+```
+
+**100x improvement** from ~1 miss per session to nearly zero.
+
+The data helped identify which interventions worked - boot gates, entity context checks, outcome storage directives. When a pattern stayed high, we added targeted fixes.
+
+There's something satisfying about an AI system that can remember things, analyze its own past behavior, identify where it failed, and track improvement over time.

{opencode_semantic_memory-0.4.1 → opencode_semantic_memory-0.5.0}/src/opencode_memory/background_worker.py

@@ -270,14 +270,17 @@ class BackgroundWorker:
     # -------------------------------------------------------------------------
 
     async def run_knowledge_extraction(self) -> int:
-        """Extract knowledge from conversations using LLM. Returns count extracted."""
+        """Extract knowledge from conversations using LLM. Returns count extracted.
+
+        Requires an LLM provider to be available.
+        """
         from opencode_memory.extraction import (
-            _find_opencode,
             extract_knowledge_from_conversation,
             get_unprocessed_conversations,
         )
+        from opencode_memory.llm import is_llm_available
 
-        if not _find_opencode():
+        if not is_llm_available(self.config):
             return 0
 
         conversations = get_unprocessed_conversations(
@@ -320,8 +323,15 @@ class BackgroundWorker:
     # -------------------------------------------------------------------------
 
     async def run_concept_extraction(self) -> int:
-        """Extract concepts from memories using LLM. Returns count of concepts created."""
+        """Extract concepts from memories using LLM. Returns count of concepts created.
+
+        Requires an LLM provider to be available.
+        """
         from opencode_memory.extraction import extract_concepts_batch
+        from opencode_memory.llm import is_llm_available
+
+        if not is_llm_available(self.config):
+            return 0
 
         try:
             stats = await extract_concepts_batch(
@@ -330,6 +340,7 @@ class BackgroundWorker:
                 embeddings=self.embeddings,
                 batch_size=CONCEPT_EXTRACTION_BATCH,
                 working_directory=self.config.ingestion.working_directory,
+                config=self.config,
             )
 
             if stats["processed"] > 0:
@@ -437,7 +448,18 @@ class BackgroundWorker:
 
         llm_enabled = self.config.ingestion.llm_extraction
         if llm_enabled:
-            logger.info("LLM extraction enabled")
+            from opencode_memory.llm import get_llm_status, is_llm_available
+
+            if is_llm_available(self.config):
+                status = get_llm_status(self.config)
+                provider = status["provider"]
+                model = status.get("model") or "default"
+                logger.info(f"LLM extraction enabled (provider: {provider}, model: {model})")
+            else:
+                logger.info(
+                    f"LLM extraction configured but provider '{self.config.llm.provider}' not found - "
+                    "LLM features disabled"
+                )
 
         try:
             while self._running:

{opencode_semantic_memory-0.4.1 → opencode_semantic_memory-0.5.0}/src/opencode_memory/config.py

@@ -60,6 +60,51 @@ class OrbitConfig(BaseModel):
     fallback_on_error: bool = True  # Fall back to REST if Orbit fails
 
 
+class LLMConfig(BaseModel):
+    """Configuration for LLM provider used in extraction and introspection.
+
+    Supported providers:
+    - opencode: OpenCode CLI (default) - uses your configured OpenCode LLM
+    - claude: Anthropic Claude CLI (claude-cli package)
+    - duo: GitLab Duo CLI (glab duo ask)
+    - ollama: Local Ollama instance
+    - custom: Custom command with args template
+
+    Example configurations:
+
+    # OpenCode (default)
+    [llm]
+    provider = "opencode"
+
+    # Claude CLI
+    [llm]
+    provider = "claude"
+    model = "claude-sonnet-4-20250514"  # optional, uses CLI default
+
+    # GitLab Duo
+    [llm]
+    provider = "duo"
+
+    # Ollama with specific model
+    [llm]
+    provider = "ollama"
+    model = "qwen2.5:14b"
+
+    # Custom command
+    [llm]
+    provider = "custom"
+    command = "my-llm-cli"
+    args = ["--prompt"]  # prompt is appended after these args
+    """
+
+    provider: str = "opencode"  # opencode, claude, duo, ollama, custom
+    model: str | None = None  # Model name (required for ollama, optional for others)
+    command: str | None = None  # Override command path (auto-detected if not set)
+    args: list[str] = Field(default_factory=list)  # Extra args for custom provider
+    timeout: int = 120  # Timeout in seconds for LLM calls
+    working_directory: str | None = None  # Working directory for CLI calls
+
+
 class Config(BaseModel):
     """Main configuration."""
 
@@ -68,6 +113,7 @@ class Config(BaseModel):
     ingestion: IngestionConfig = Field(default_factory=IngestionConfig)
     storage: StorageConfig = Field(default_factory=StorageConfig)
     orbit: OrbitConfig = Field(default_factory=OrbitConfig)
+    llm: LLMConfig = Field(default_factory=LLMConfig)
 
     @classmethod
     def load(cls, config_path: Path | None = None) -> "Config":