@hir4ta/mneme 0.17.0

package/hooks/hooks.json

@@ -0,0 +1,61 @@
+{
+  "description": "mneme plugin hooks for session management, auto-save, and memory search",
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/user-prompt-submit.sh",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session-start.sh",
+            "timeout": 15
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/pre-compact.sh",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session-end.sh",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/post-tool-use.sh",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/post-tool-use.sh

@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+#
+# post-tool-use.sh - Post-tool use hook for Bash operations
+#
+# This hook is called after Bash tool execution.
+# It detects errors, searches for matching patterns in mneme,
+# and suggests solutions from past error-solution patterns.
+#
+# Input (stdin): JSON with tool_name, tool_input, tool_response, cwd
+# Output (stdout): JSON with {"continue": true} and optional additionalContext
+# Exit codes: 0 = success (non-blocking)
+#
+# Dependencies: jq
+
+set -euo pipefail
+
+# Read stdin
+input_json=$(cat)
+
+# Extract relevant fields (tool_response is the official field name)
+exit_code=$(echo "$input_json" | jq -r '.tool_response.exit_code // .tool_result.exit_code // 0')
+stderr=$(echo "$input_json" | jq -r '.tool_response.stderr // .tool_result.stderr // ""')
+command=$(echo "$input_json" | jq -r '.tool_input.command // ""')
+cwd=$(echo "$input_json" | jq -r '.cwd // empty')
+
+# If no cwd, use PWD
+if [ -z "$cwd" ]; then
+  cwd="${PWD}"
+fi
+
+# Check for error conditions
+if [[ "$exit_code" != "0" && -n "$stderr" ]]; then
+  # Error detected - search for matching patterns first
+
+  patterns_dir="${cwd}/.mneme/patterns"
+  matched_solution=""
+  matched_pattern=""
+  matched_reasoning=""
+
+  # Search patterns if directory exists
+  if [ -d "$patterns_dir" ]; then
+    # Get first 500 chars of stderr for matching
+    stderr_sample=$(echo "$stderr" | head -c 500)
+
+    # Search through all pattern files
+    for pattern_file in "$patterns_dir"/*.json; do
+      [ -f "$pattern_file" ] || continue
+
+      # Extract error-solution patterns and check for matches (tab-separated output)
+      match_result=$(jq -r --arg stderr "$stderr_sample" '
+        [.patterns // [] | .[] | select(type == "object" and .type == "error-solution")] as $patterns
+        | [$patterns[] |
+            . as $p |
+            (if ($p.errorRegex // "" | length > 0) and ($stderr | test($p.errorRegex; "i")) then true
+             elif ($p.errorPattern // "" | length > 0) and ($stderr | contains($p.errorPattern)) then true
+             else false end) as $matched |
+            select($matched)
+          ]
+        | if length > 0 then
+            .[0] | "MATCH\t" + (.errorPattern // "unknown") + "\t" + (.solution // "no solution") + "\t" + (.reasoning // "")
+          else
+            empty
+          end
+      ' "$pattern_file" 2>/dev/null || echo "")
+
+      if [[ "$match_result" == MATCH$'\t'* ]]; then
+        # Parse the tab-separated match result
+        matched_pattern=$(echo "$match_result" | cut -f2)
+        matched_solution=$(echo "$match_result" | cut -f3)
+        matched_reasoning=$(echo "$match_result" | cut -f4)
+        break
+      fi
+    done
+  fi
+
+  # Build suggestion message
+  if [ -n "$matched_solution" ]; then
+    # Pattern match found - suggest the solution
+    suggestion="**Past solution found:**\\n"
+    suggestion+="Error pattern: ${matched_pattern}\\n"
+    suggestion+="Solution: ${matched_solution}\\n"
+    if [ -n "$matched_reasoning" ]; then
+      suggestion+="Reasoning: ${matched_reasoning}\\n"
+    fi
+    suggestion+="\\nApply this solution?"
+  else
+    # No match - just note the error
+    suggestion="Error detected (exit code: $exit_code). No matching pattern found in mneme."
+  fi
+
+  # Output with additionalContext
+  printf '{"continue": true, "additionalContext": "%s"}\n' "$suggestion"
+else
+  # No error - continue normally
+  echo '{"continue": true}'
+fi

package/hooks/pre-compact.sh

@@ -0,0 +1,187 @@
+#!/usr/bin/env bash
+#
+# pre-compact.sh - Backup interactions before Auto-Compact
+#
+# Saves current interactions to project-local SQLite (.mneme/local.db)
+# pre_compact_backups table before context is compressed.
+# Does NOT create summary - summary creation is manual via /mneme:save.
+#
+# Input (stdin): JSON with session_id, transcript_path, cwd, trigger
+# Output (stdout): JSON with {"continue": true}
+# Exit codes: 0 = success (non-blocking, always continues)
+#
+# Dependencies: jq, sqlite3
+
+set -euo pipefail
+
+# Read stdin
+input_json=$(cat)
+
+# Extract fields
+session_id=$(echo "$input_json" | jq -r '.session_id // empty')
+transcript_path=$(echo "$input_json" | jq -r '.transcript_path // empty')
+cwd=$(echo "$input_json" | jq -r '.cwd // empty')
+
+# If no cwd, use PWD
+if [ -z "$cwd" ]; then
+    cwd="${PWD}"
+fi
+
+# Find session file
+if [ -z "$session_id" ]; then
+    echo '{"continue": true}'
+    exit 0
+fi
+
+session_short_id="${session_id:0:8}"
+mneme_dir="${cwd}/.mneme"
+sessions_dir="${mneme_dir}/sessions"
+session_links_dir="${mneme_dir}/session-links"
+
+# Local database path (project-local)
+db_path="${mneme_dir}/local.db"
+
+# The session ID to use for storing data (may be updated to master session ID)
+mneme_session_id="$session_short_id"
+
+# First, try to find session file with current session ID
+session_file=$(find "$sessions_dir" -name "${session_short_id}.json" -type f 2>/dev/null | head -1)
+
+# If not found, check session-links for master session ID
+if [ -z "$session_file" ] || [ ! -f "$session_file" ]; then
+    session_link_file="${session_links_dir}/${session_short_id}.json"
+    if [ -f "$session_link_file" ]; then
+        master_session_id=$(jq -r '.masterSessionId // empty' "$session_link_file" 2>/dev/null || echo "")
+        if [ -n "$master_session_id" ]; then
+            session_file=$(find "$sessions_dir" -type f -name "${master_session_id}.json" 2>/dev/null | head -1)
+            if [ -n "$session_file" ] && [ -f "$session_file" ]; then
+                mneme_session_id="$master_session_id"
+                echo "[mneme] PreCompact: Using master session via session-link: ${master_session_id}" >&2
+            fi
+        fi
+    fi
+fi
+
+if [ -z "$session_file" ] || [ ! -f "$session_file" ]; then
+    echo '{"continue": true}'
+    exit 0
+fi
+
+# Get git user for owner field
+owner=$(git -C "$cwd" config user.name 2>/dev/null || whoami || echo "unknown")
+
+# Escape project path for SQL
+project_path_escaped="${cwd//\'/\'\'}"
+
+# Determine plugin root directory for schema
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+PLUGIN_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+schema_path="${PLUGIN_ROOT}/lib/schema.sql"
+
+# Initialize local SQLite database if not exists
+init_database() {
+    if [ ! -d "$mneme_dir" ]; then
+        mkdir -p "$mneme_dir"
+    fi
+    if [ ! -f "$db_path" ]; then
+        if [ -f "$schema_path" ]; then
+            sqlite3 "$db_path" < "$schema_path"
+            echo "[mneme] Local SQLite database initialized: ${db_path}" >&2
+        else
+            # Minimal schema if schema.sql not found
+            sqlite3 "$db_path" <<'SQLEOF'
+CREATE TABLE IF NOT EXISTS interactions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    project_path TEXT NOT NULL,
+    repository TEXT,
+    repository_url TEXT,
+    repository_root TEXT,
+    owner TEXT NOT NULL,
+    role TEXT NOT NULL,
+    content TEXT NOT NULL,
+    thinking TEXT,
+    tool_calls TEXT,
+    timestamp TEXT NOT NULL,
+    is_compact_summary INTEGER DEFAULT 0,
+    created_at TEXT DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_interactions_session ON interactions(session_id);
+CREATE INDEX IF NOT EXISTS idx_interactions_owner ON interactions(owner);
+CREATE INDEX IF NOT EXISTS idx_interactions_project ON interactions(project_path);
+
+CREATE TABLE IF NOT EXISTS pre_compact_backups (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    project_path TEXT NOT NULL,
+    owner TEXT NOT NULL,
+    interactions TEXT NOT NULL,
+    created_at TEXT DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_backups_session ON pre_compact_backups(session_id);
+CREATE INDEX IF NOT EXISTS idx_backups_project ON pre_compact_backups(project_path);
+SQLEOF
+        fi
+    fi
+    # Configure pragmas
+    sqlite3 "$db_path" "PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000; PRAGMA synchronous = NORMAL;" 2>/dev/null || true
+}
+
+echo "[mneme] PreCompact: Backing up interactions before Auto-Compact..." >&2
+
+# Extract current interactions from transcript (same logic as session-end.sh)
+if [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
+    # Initialize database
+    init_database
+
+    interactions_json=$(cat "$transcript_path" | jq -s '
+        # User messages (text only, exclude tool results)
+        [.[] | select(.type == "user" and .message.role == "user" and (.message.content | type) == "string") | {
+            timestamp: .timestamp,
+            content: .message.content
+        }] as $user_messages |
+
+        # All assistant messages with thinking or text
+        [.[] | select(.type == "assistant") | . as $msg |
+            ($msg.message.content // []) |
+            {
+                timestamp: $msg.timestamp,
+                thinking: ([.[] | select(.type == "thinking") | .thinking] | join("\n")),
+                text: ([.[] | select(.type == "text") | .text] | join("\n"))
+            } | select(.thinking != "" or .text != "")
+        ] as $all_assistant |
+
+        # Build interactions by grouping all assistant responses between user messages
+        [range(0; $user_messages | length) | . as $i |
+            $user_messages[$i] as $user |
+            # Get next user message timestamp (or far future if last)
+            (if $i + 1 < ($user_messages | length) then $user_messages[$i + 1].timestamp else "9999-12-31T23:59:59Z" end) as $next_user_ts |
+            # Collect all assistant responses between this user message and next
+            [$all_assistant[] | select(.timestamp > $user.timestamp and .timestamp < $next_user_ts)] as $turn_responses |
+            if ($turn_responses | length) > 0 then {
+                id: ("int-" + (($i + 1) | tostring | if length < 3 then "00"[0:(3-length)] + . else . end)),
+                timestamp: $user.timestamp,
+                user: $user.content,
+                thinking: ([$turn_responses[].thinking | select(. != "")] | join("\n")),
+                assistant: ([$turn_responses[].text | select(. != "")] | join("\n"))
+            } else empty end
+        ]
+    ' 2>/dev/null || echo '[]')
+
+    interaction_count=$(echo "$interactions_json" | jq 'length')
+
+    if [ "$interaction_count" -gt 0 ]; then
+        # Escape single quotes for SQL
+        interactions_escaped="${interactions_json//\'/\'\'}"
+
+        # Insert backup into local SQLite with project_path (use master session ID if linked)
+        sqlite3 "$db_path" "INSERT INTO pre_compact_backups (session_id, project_path, owner, interactions) VALUES ('${mneme_session_id}', '${project_path_escaped}', '${owner}', '${interactions_escaped}');" 2>/dev/null || true
+
+        echo "[mneme] PreCompact: Backed up ${interaction_count} interactions to local DB" >&2
+    else
+        echo "[mneme] PreCompact: No interactions to backup" >&2
+    fi
+fi
+
+# Continue with compaction (non-blocking)
+echo '{"continue": true}'