opencode-claude-memory 1.6.2 → 1.6.4

package/README.md

@@ -29,6 +29,30 @@ Claude Code writes memory → OpenCode reads it. OpenCode writes memory → Clau
 
 ## 🚀 Quick Start
 
+### Prerequisites
+
+- `opencode`
+- `python3` available in `PATH`
+
+`python3` is a runtime dependency for the wrapper's scoped session detection and fork cleanup logic.
+If it is missing or not executable, post-session maintenance becomes less reliable: session targeting can fall back to less precise heuristics, and fork cleanup is skipped for safety.
+
+Common install commands:
+
+```bash
+# macOS (Homebrew)
+brew install python
+
+# Ubuntu / Debian
+sudo apt-get update && sudo apt-get install -y python3
+
+# Fedora
+sudo dnf install -y python3
+
+# Arch Linux
+sudo pacman -S python
+```
+
 ### 1. Install
 
 ```bash
@@ -41,6 +65,8 @@ This installs:
 - The `opencode-memory` **CLI** — wraps opencode with automatic memory extraction + auto-dream consolidation
 - A **shell hook** — defines an `opencode()` function in your `.zshrc`/`.bashrc` that delegates to `opencode-memory`
 
+If `python3` is not installed yet, install it first using the commands above before enabling the shell hook.
+
 ### 2. Configure
 
 ```jsonc
@@ -118,6 +144,18 @@ The shell hook defines an `opencode()` function that delegates to `opencode-memo
 8. Maintenance runs **in the background** unless `OPENCODE_MEMORY_FOREGROUND=1`
 9. Terminal maintenance logs are shown in foreground mode by default, or can be forced on/off with `OPENCODE_MEMORY_TERMINAL_LOG=1|0`
 
+### Runtime dependencies
+
+The wrapper expects `python3` to be available at runtime.
+
+It is used for:
+
+- scoped session selection from `opencode session list`
+- parsing `opencode export` output to resolve session directories
+- safely identifying and cleaning up forked extraction / auto-dream sessions
+
+Without `python3`, the plugin tools still load, but wrapper maintenance is degraded and fork cleanup is intentionally skipped to avoid deleting the wrong session.
+
 ### Compatibility details
 
 The implementation ports core logic from Claude Code for path hashing, git-root/worktree handling, memory format, and memory prompting behavior, so both tools can operate on the same files safely.

package/bin/opencode-memory

@@ -473,22 +473,58 @@ get_latest_session_id() {
   fi
 }
 
+get_opencode_db_path() {
+  printf '%s\n' "$HOME/.local/share/opencode/opencode.db"
+}
+
+get_session_title_from_db() {
+  local session_id="$1"
+  local db_path
+  db_path=$(get_opencode_db_path)
+
+  if [ -z "$session_id" ] || [ ! -f "$db_path" ] || ! command -v python3 >/dev/null 2>&1; then
+    return 1
+  fi
+
+  python3 - "$db_path" "$session_id" <<'PY'
+import sqlite3
+import sys
+
+db_path, session_id = sys.argv[1:3]
+
+try:
+    conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+    row = conn.execute("SELECT title FROM session WHERE id = ? LIMIT 1", (session_id,)).fetchone()
+except Exception:
+    raise SystemExit(1)
+finally:
+    try:
+        conn.close()
+    except Exception:
+        pass
+
+if row and row[0]:
+    print(row[0])
+PY
+}
+
 get_session_target_id() {
   local before_json="$1"
   local started_at_ms="$2"
   local workdir="$3"
   local project_dir="$4"
+  local allow_existing_fallback="${5:-1}"
   local after_json
 
   after_json=$(get_session_list_json "$AUTODREAM_SCAN_LIMIT") || return 1
 
   if command -v python3 >/dev/null 2>&1; then
-    python3 - "$before_json" "$after_json" "$started_at_ms" "$workdir" "$project_dir" <<'PY'
+    python3 - "$before_json" "$after_json" "$started_at_ms" "$workdir" "$project_dir" "$allow_existing_fallback" <<'PY'
 import json
 import os
 import sys
 
-before_raw, after_raw, started_at_ms_raw, workdir, project_dir = sys.argv[1:6]
+before_raw, after_raw, started_at_ms_raw, workdir, project_dir, allow_existing_fallback_raw = sys.argv[1:7]
 
 def parse(raw):
     try:
@@ -522,6 +558,7 @@ def normalize(path):
 before = parse(before_raw)
 after = parse(after_raw)
 started_at_ms = int(started_at_ms_raw or "0")
+allow_existing_fallback = allow_existing_fallback_raw == "1"
 before_ids = {item.get("id") for item in before if item.get("id")}
 workdir = normalize(workdir)
 project_dir = normalize(project_dir)
@@ -544,11 +581,15 @@ def choose(candidates):
 new_sessions = [item for item in after if item.get("id") not in before_ids]
 updated_sessions = [item for item in after if timestamp(item) > started_at_ms]
 
-for pool in (
+candidate_pools = [
     [item for item in new_sessions if in_scope(item)],
     [item for item in updated_sessions if in_scope(item)],
-    [item for item in after if in_scope(item)],
-):
+]
+
+if allow_existing_fallback:
+    candidate_pools.append([item for item in after if in_scope(item)])
+
+for pool in candidate_pools:
     if choose(pool):
         break
 PY
@@ -795,18 +836,100 @@ main_prompt_requests_ignore_memory() {
   printf '%s\n' "$joined" | grep -Eq "(ignore|don't use|do not use|without|skip)[[:space:]]+(the[[:space:]]+)?memory|memory[[:space:]]+((should|must)[[:space:]]+be[[:space:]]+)?ignored"
 }
 
-wait_for_session_target_id() {
+wait_for_scoped_session_id_since() {
   local before_json="$1"
   local started_at_ms="$2"
-  local wait_seconds="${3:-5}"
+  local timestamp_file="$3"
+  local wait_seconds="${4:-5}"
+  local allow_existing_fallback="${5:-1}"
   local attempt=0
   local session_id=""
 
   while [ "$attempt" -lt "$wait_seconds" ]; do
-    session_id=$(get_session_target_id "$before_json" "$started_at_ms" "$WORKING_DIR" "$PROJECT_SCOPE_DIR" || true)
+    session_id=$(get_session_target_id "$before_json" "$started_at_ms" "$WORKING_DIR" "$PROJECT_SCOPE_DIR" "$allow_existing_fallback" || true)
     if [ -z "$session_id" ]; then
-      session_id=$(get_scoped_artifact_session_id_since "$TIMESTAMP_FILE" "$WORKING_DIR" "$PROJECT_SCOPE_DIR" || true)
+      session_id=$(get_scoped_artifact_session_id_since "$timestamp_file" "$WORKING_DIR" "$PROJECT_SCOPE_DIR" || true)
+    fi
+    if [ -n "$session_id" ]; then
+      printf '%s\n' "$session_id"
+      return 0
     fi
+    sleep 1
+    attempt=$((attempt + 1))
+  done
+
+  return 1
+}
+
+wait_for_session_target_id() {
+  local before_json="$1"
+  local started_at_ms="$2"
+  local wait_seconds="${3:-5}"
+
+  wait_for_scoped_session_id_since "$before_json" "$started_at_ms" "$TIMESTAMP_FILE" "$wait_seconds"
+}
+
+get_fork_cleanup_candidate_id() {
+  local started_at_ms="$1"
+  local parent_title="$2"
+  local workdir="$3"
+  local project_dir="$4"
+  local db_path
+  db_path=$(get_opencode_db_path)
+
+  if [ -z "$started_at_ms" ] || [ -z "$parent_title" ] || [ ! -f "$db_path" ] || ! command -v python3 >/dev/null 2>&1; then
+    return 1
+  fi
+
+  python3 - "$db_path" "$started_at_ms" "$parent_title" "$workdir" "$project_dir" <<'PY'
+import os
+import re
+import sqlite3
+import sys
+
+db_path, started_at_ms_raw, parent_title, workdir, project_dir = sys.argv[1:6]
+started_at_ms = int(started_at_ms_raw or "0")
+scope = {os.path.realpath(path) for path in (workdir, project_dir) if path}
+title_pattern = re.compile(rf"^{re.escape(parent_title)} \(fork #\d+\)$")
+
+try:
+    conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+    rows = conn.execute(
+        "SELECT id, title, directory, time_created FROM session WHERE time_created >= ? ORDER BY time_created DESC",
+        (started_at_ms,),
+    ).fetchall()
+except Exception:
+    raise SystemExit(1)
+finally:
+    try:
+        conn.close()
+    except Exception:
+        pass
+
+matches = []
+for session_id, title, directory, time_created in rows:
+    if not session_id or not title or not directory or not time_created:
+        continue
+    if os.path.realpath(directory) not in scope:
+        continue
+    if not title_pattern.match(title):
+        continue
+    matches.append(session_id)
+
+if len(matches) == 1:
+    print(matches[0])
+PY
+}
+
+wait_for_fork_cleanup_candidate_id() {
+  local started_at_ms="$1"
+  local parent_title="$2"
+  local wait_seconds="${3:-5}"
+  local attempt=0
+  local session_id=""
+
+  while [ "$attempt" -lt "$wait_seconds" ]; do
+    session_id=$(get_fork_cleanup_candidate_id "$started_at_ms" "$parent_title" "$WORKING_DIR" "$PROJECT_SCOPE_DIR" || true)
     if [ -n "$session_id" ]; then
       printf '%s\n' "$session_id"
       return 0
@@ -957,59 +1080,32 @@ rollback_consolidation_lock() {
 }
 
 cleanup_forked_sessions() {
-  local before_json="$1"
+  local started_at_ms="$1"
+  local parent_title="$2"
 
-  if ! command -v python3 >/dev/null 2>&1; then
+  if [ -z "$started_at_ms" ] || [ -z "$parent_title" ]; then
     return 0
   fi
 
-  local after_json
-  after_json=$(get_session_list_json 10 2>/dev/null || true)
-
-  if [ -z "$before_json" ] || [ -z "$after_json" ]; then
+  if ! command -v python3 >/dev/null 2>&1; then
     return 0
   fi
 
-  local fork_ids
-  fork_ids=$(python3 - "$before_json" "$after_json" "$WORKING_DIR" "$PROJECT_SCOPE_DIR" <<'PY'
-import json
-import os
-import sys
-
-def parse(raw):
-    try:
-        data = json.loads(raw)
-        return data if isinstance(data, list) else []
-    except Exception:
-        return []
-
-before_raw, after_raw, workdir, project_dir = sys.argv[1:5]
-before = parse(before_raw)
-after = parse(after_raw)
+  if ! python3 - <<'PY' >/dev/null 2>&1
+pass
+PY
+  then
+    return 0
+  fi
 
-before_ids = {item.get("id") for item in before if item.get("id")}
-workdir = os.path.realpath(workdir)
-project_dir = os.path.realpath(project_dir)
+  local fork_id
+  fork_id=$(wait_for_fork_cleanup_candidate_id "$started_at_ms" "$parent_title" "$SESSION_WAIT_SECONDS" || true)
 
-for item in after:
-    sid = item.get("id", "")
-    if not sid or sid in before_ids:
-        continue
-    directory = item.get("directory", "")
-    if not directory:
-        continue
-    d = os.path.realpath(directory)
-    if d in (workdir, project_dir):
-        print(sid)
-PY
-  ) || return 0
+  [ -n "$fork_id" ] || return 0
 
-  while IFS= read -r fork_id; do
-    [ -n "$fork_id" ] || continue
-    if "$REAL_OPENCODE" session delete "$fork_id" >/dev/null 2>&1; then
-      log "Cleaned up forked session $fork_id"
-    fi
-  done <<< "$fork_ids"
+  if "$REAL_OPENCODE" session delete "$fork_id" >/dev/null 2>&1; then
+    log "Cleaned up forked session $fork_id"
+  fi
 }
 
 session_has_conversation() {
@@ -1050,6 +1146,9 @@ run_extraction_if_needed() {
   log "Extracting memories from session $session_id..."
   log "Extraction log: $EXTRACT_LOG_FILE"
 
+  local parent_session_title
+  parent_session_title=$(get_session_title_from_db "$session_id" || true)
+
   local cmd=("$REAL_OPENCODE" run -s "$session_id" --fork --dir "$WORKING_DIR")
   if [ -n "$EXTRACT_MODEL" ]; then
     cmd+=(-m "$EXTRACT_MODEL")
@@ -1059,8 +1158,8 @@ run_extraction_if_needed() {
   fi
   cmd+=("$EXTRACT_PROMPT")
 
-  local pre_fork_json
-  pre_fork_json=$(get_session_list_json 5 2>/dev/null || true)
+  local fork_started_at_ms
+  fork_started_at_ms=$(( $(date +%s) * 1000 ))
 
   if "${cmd[@]}" >> "$EXTRACT_LOG_FILE" 2>&1; then
     log "Memory extraction completed successfully"
@@ -1069,7 +1168,7 @@ run_extraction_if_needed() {
     log "Memory extraction failed (exit code $code). Check $EXTRACT_LOG_FILE for details"
   fi
 
-  cleanup_forked_sessions "$pre_fork_json"
+  cleanup_forked_sessions "$fork_started_at_ms" "$parent_session_title"
   release_simple_lock "$EXTRACT_LOCK_FILE"
 }
 
@@ -1112,6 +1211,9 @@ run_autodream_if_needed() {
   log "Auto-dream firing (${hours_since}h since last consolidation, ${touched_count} sessions touched)"
   log "Auto-dream log: $AUTODREAM_LOG_FILE"
 
+  local parent_session_title
+  parent_session_title=$(get_session_title_from_db "$session_id" || true)
+
   local cmd=("$REAL_OPENCODE" run -s "$session_id" --fork --dir "$WORKING_DIR")
   if [ -n "$AUTODREAM_MODEL" ]; then
     cmd+=(-m "$AUTODREAM_MODEL")
@@ -1121,8 +1223,8 @@ run_autodream_if_needed() {
   fi
   cmd+=("$AUTODREAM_PROMPT")
 
-  local pre_fork_json
-  pre_fork_json=$(get_session_list_json 5 2>/dev/null || true)
+  local fork_started_at_ms
+  fork_started_at_ms=$(( $(date +%s) * 1000 ))
 
   if "${cmd[@]}" >> "$AUTODREAM_LOG_FILE" 2>&1; then
     log "Auto-dream consolidation completed successfully"
@@ -1133,7 +1235,7 @@ run_autodream_if_needed() {
     rollback_consolidation_lock "$CONSOLIDATION_PRIOR_MTIME"
   fi
 
-  cleanup_forked_sessions "$pre_fork_json"
+  cleanup_forked_sessions "$fork_started_at_ms" "$parent_session_title"
 }
 
 run_post_session_tasks() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claude-memory",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "type": "module",
   "description": "Claude Code-compatible memory compatibility layer for OpenCode — zero config, local-first, no migration",
   "main": "dist/index.js",