refactor: rename semantic-memory to sem-mem throughout codebase

- Rename Python module: src/semantic_memory/ → src/sem_mem/
- Rename class: SemanticMemoryApp → SemMemApp
- Update CLI command: semantic-memory → sem-mem
- Update all imports, configs, docs, and tests
- Fix CI: mock OpenAI embeddings in test_server.py
- Add injectable embeddings param to create_app()
- Add semver release workflow (.github/workflows/release.yml)
- Add one-time setup script (scripts/setup.sh)
- Rename skill: using-semantic-memory → using-sem-mem
- Update default DB path: ~/.claude/sem-mem/memory.db

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: emmahyde

.claude-plugin/plugin.json

@@ -1,12 +1,12 @@
 {
-  "name": "semantic-memory",
+  "name": "sem-mem",
   "version": "1.0.0",
-  "description": "Teaches Claude how to use the semantic-memory MCP server for persistent knowledge storage, retrieval, and graph traversal. Includes PreCompact hook to preserve insights before context compaction.",
+  "description": "Teaches Claude how to use the sem-mem MCP server for persistent knowledge storage, retrieval, and graph traversal. Includes PreCompact hook to preserve insights before context compaction.",
   "author": {
     "name": "Emma Hyde"
   },
   "homepage": "https://github.com/emmahyde/brainspace",
   "repository": "https://github.com/emmahyde/brainspace",
   "license": "MIT",
-  "keywords": ["semantic-memory", "mcp", "knowledge-graph", "embeddings", "insights"]
+  "keywords": ["sem-mem", "mcp", "knowledge-graph", "embeddings", "insights"]
 }

.github/workflows/release.yml

@@ -0,0 +1,102 @@
+name: Release
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    # Skip if commit message contains [skip ci] or [skip release]
+    if: "!contains(github.event.head_commit.message, '[skip ci]') && !contains(github.event.head_commit.message, '[skip release]')"
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Determine version bump type
+        id: bump_type
+        run: |
+          # Get PR number from merge commit
+          PR_NUMBER=$(echo "${{ github.event.head_commit.message }}" | grep -oP '(?<=#)\d+(?=\))' || echo "")
+
+          BUMP_TYPE="patch"
+
+          # Check commit message for conventional commit patterns
+          if echo "${{ github.event.head_commit.message }}" | grep -qE "BREAKING CHANGE|^[a-z]+!:"; then
+            BUMP_TYPE="major"
+          elif echo "${{ github.event.head_commit.message }}" | grep -qE "^feat:"; then
+            BUMP_TYPE="minor"
+          elif [ -n "$PR_NUMBER" ]; then
+            # Check PR labels if we have a PR number
+            LABELS=$(gh pr view "$PR_NUMBER" --json labels --jq '.labels[].name' || echo "")
+            if echo "$LABELS" | grep -q "major"; then
+              BUMP_TYPE="major"
+            elif echo "$LABELS" | grep -q "minor"; then
+              BUMP_TYPE="minor"
+            fi
+          fi
+
+          echo "bump_type=$BUMP_TYPE" >> $GITHUB_OUTPUT
+          echo "Detected bump type: $BUMP_TYPE"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Bump version
+        id: bump_version
+        run: |
+          # Read current version
+          CURRENT_VERSION=$(grep '^version = ' pyproject.toml | sed 's/version = "\(.*\)"/\1/')
+          echo "Current version: $CURRENT_VERSION"
+
+          # Split version into parts
+          IFS='.' read -r MAJOR MINOR PATCH <<< "$CURRENT_VERSION"
+
+          # Bump based on type
+          case "${{ steps.bump_type.outputs.bump_type }}" in
+            major)
+              MAJOR=$((MAJOR + 1))
+              MINOR=0
+              PATCH=0
+              ;;
+            minor)
+              MINOR=$((MINOR + 1))
+              PATCH=0
+              ;;
+            patch)
+              PATCH=$((PATCH + 1))
+              ;;
+          esac
+
+          NEW_VERSION="$MAJOR.$MINOR.$PATCH"
+          echo "New version: $NEW_VERSION"
+
+          # Update pyproject.toml
+          sed -i "s/^version = \".*\"/version = \"$NEW_VERSION\"/" pyproject.toml
+
+          echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+
+      - name: Commit version bump
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add pyproject.toml
+          git commit -m "chore: bump version to ${{ steps.bump_version.outputs.new_version }} [skip ci]"
+          git push
+
+      - name: Create tag and release
+        run: |
+          TAG="v${{ steps.bump_version.outputs.new_version }}"
+          git tag "$TAG"
+          git push origin "$TAG"
+
+          # Create GitHub release (this triggers publish.yml)
+          gh release create "$TAG" \
+            --title "Release $TAG" \
+            --generate-notes
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

CLAUDE.md

@@ -22,7 +22,7 @@ uv run pytest tests/test_storage.py
 uv run pytest tests/test_storage.py::TestInsightStoreInit::test_initialize_creates_tables
 
 # Run MCP server directly
-uv run semantic-memory
+uv run sem-mem
 ```
 
 ## Architecture
@@ -31,17 +31,17 @@ uv run semantic-memory
 
 **Data flow (search):** Query → embed → cosine similarity search in `InsightStore`, or subject-based lookup, or graph traversal via shared-subject relations.
 
-### Source layout (`src/semantic_memory/`)
+### Source layout (`src/sem_mem/`)
 
 - **`models.py`** — `Frame` enum (CAUSAL, CONSTRAINT, PATTERN, EQUIVALENCE, TAXONOMY, PROCEDURE), `Insight`, `GitContext`, `SearchResult`
 - **`normalizer.py`** — LLM decomposition/classification via Anthropic API (or Bedrock). Uses `DECOMPOSE_PROMPT` and `CLASSIFY_PROMPT`
 - **`embeddings.py`** — Embedding generation (OpenAI or Bedrock Titan), L2-normalized float32 vectors. `create_embedding_engine()` factory selects provider.
 - **`storage.py`** — `InsightStore` class: SQLite persistence, migration system, subject indexing, knowledge graph queries
-- **`server.py`** — `SemanticMemoryApp` orchestrator + MCP tool definitions (9 tools: `store_insight`, `search_insights`, `list_insights`, `update_insight`, `forget`, `search_by_subject`, `related_insights`, `add_subject_relation`, `get_subject_relations`)
+- **`server.py`** — `SemMemApp` orchestrator + MCP tool definitions (9 tools: `store_insight`, `search_insights`, `list_insights`, `update_insight`, `forget`, `search_by_subject`, `related_insights`, `add_subject_relation`, `get_subject_relations`)
 
 ### Database
 
-Default location: `~/.claude/semantic-memory/memory.db` (override with `MEMORY_DB_PATH` env var).
+Default location: `~/.claude/sem-mem/memory.db` (override with `MEMORY_DB_PATH` env var).
 
 Four tables: `insights`, `subjects` (with `insight_subjects` junction), `insight_relations`, `subject_relations`. Schema versioned via `schema_versions` table.
 
@@ -72,4 +72,4 @@ Migrations are Python functions in `storage.py` (named `_migrate_NNN_*`), tracke
 
 ## Plugin
 
-This repo is also a Claude Code plugin (`claude plugin install semantic-memory@brainspace`). Plugin files live at the repo root: `.claude-plugin/`, `skills/`, `hooks/`. Includes a `using-semantic-memory` skill and a `PreCompact` hook.
+This repo is also a Claude Code plugin (`claude plugin install sem-mem@brainspace`). Plugin files live at the repo root: `.claude-plugin/`, `skills/`, `hooks/`. Includes a `using-sem-mem` skill and a `PreCompact` hook.

README.md

@@ -1,4 +1,4 @@
-# semantic-memory
+# sem-mem
 
 An MCP server that gives AI agents persistent, intent-based memory. Text is decomposed into atomic insights, classified into semantic frames, embedded as vectors, and stored in a SQLite knowledge graph with subject indexing.
 
@@ -43,14 +43,14 @@ export AWS_REGION=us-east-1
 ### 3. Install the Claude Code plugin
 
 ```bash
-claude plugin install semantic-memory@brainspace
+claude plugin install sem-mem@brainspace
 ```
 
 ### 4. Verify
 
 ```bash
 uv run pytest          # 85 tests pass
-uv run semantic-memory # server starts
+uv run sem-mem # server starts
 ```
 
 ## Configuration
@@ -61,7 +61,7 @@ uv run semantic-memory # server starts
 |---|---|---|
 | `OPENAI_API_KEY` | Yes* | Embedding generation via OpenAI (text-embedding-3-small) |
 | `ANTHROPIC_API_KEY` | Yes* | Insight normalization via Anthropic (Claude Haiku) |
-| `MEMORY_DB_PATH` | No | Database path. Default: `~/.claude/semantic-memory/memory.db` |
+| `MEMORY_DB_PATH` | No | Database path. Default: `~/.claude/sem-mem/memory.db` |
 | `EMBEDDING_PROVIDER` | No | `openai` (default) or `bedrock` |
 | `LLM_PROVIDER` | No | `anthropic` (default) or `bedrock` |
 | `AWS_PROFILE` | No | AWS SSO profile name (required for Bedrock) |
@@ -78,14 +78,14 @@ Add to your MCP settings (see `mcp-config-example.json`):
 ```json
 {
   "mcpServers": {
-    "semantic-memory": {
+    "sem-mem": {
       "command": "python3",
-      "args": ["-m", "semantic_memory.server"],
+      "args": ["-m", "sem_mem.server"],
       "env": {
-        "MEMORY_DB_PATH": "~/.claude/semantic-memory/memory.db",
+        "MEMORY_DB_PATH": "~/.claude/sem-mem/memory.db",
         "OPENAI_API_KEY": "${OPENAI_API_KEY}"
       },
-      "cwd": "/path/to/semantic-memory/src"
+      "cwd": "/path/to/sem-mem/src"
     }
   }
 }
@@ -98,17 +98,17 @@ To use AWS Bedrock instead of OpenAI/Anthropic APIs:
 ```json
 {
   "mcpServers": {
-    "semantic-memory": {
+    "sem-mem": {
       "command": "python3",
-      "args": ["-m", "semantic_memory.server"],
+      "args": ["-m", "sem_mem.server"],
       "env": {
-        "MEMORY_DB_PATH": "~/.claude/semantic-memory/memory.db",
+        "MEMORY_DB_PATH": "~/.claude/sem-mem/memory.db",
         "EMBEDDING_PROVIDER": "bedrock",
         "LLM_PROVIDER": "bedrock",
         "AWS_PROFILE": "your-sso-profile",
         "AWS_REGION": "us-east-1"
       },
-      "cwd": "/path/to/semantic-memory/src"
+      "cwd": "/path/to/sem-mem/src"
     }
   }
 }
@@ -212,9 +212,9 @@ Migrations run automatically on startup. Currently at version 4.
 This repo is also a Claude Code plugin. Install with:
 
 ```bash
-claude plugin install semantic-memory@brainspace
+claude plugin install sem-mem@brainspace
 ```
 
 Includes:
-- **Skill** (`using-semantic-memory`) — search strategy guide, subject kinds/relations reference, best practices
+- **Skill** (`using-sem-mem`) — search strategy guide, subject kinds/relations reference, best practices
 - **PreCompact hook** — prompts Claude to store key insights before context compaction

hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "Semantic Memory hooks — preserves knowledge before context compaction",
+  "description": "Sem-Mem hooks — preserves knowledge before context compaction",
   "hooks": {
     "PreCompact": [
       {

hooks/scripts/pre-compact.sh

@@ -4,7 +4,7 @@
 # otherwise be lost when the conversation window is compacted.
 #
 # Strategy: Read hook input, output a system message instructing Claude
-# to store key insights via semantic-memory MCP tools before compaction.
+# to store key insights via sem-mem MCP tools before compaction.
 
 set -euo pipefail
 

mcp-config-example.json

@@ -1,25 +1,25 @@
 {
   "mcpServers": {
-    "semantic-memory": {
+    "sem-mem": {
       "command": "python3",
-      "args": ["-m", "semantic_memory.server"],
+      "args": ["-m", "sem_mem.server"],
       "env": {
-        "MEMORY_DB_PATH": "~/.claude/semantic-memory/memory.db",
+        "MEMORY_DB_PATH": "~/.claude/sem-mem/memory.db",
         "OPENAI_API_KEY": "${OPENAI_API_KEY}"
       },
-      "cwd": "/path/to/semantic-memory/src"
+      "cwd": "/path/to/sem-mem/src"
     },
-    "semantic-memory-bedrock": {
+    "sem-mem-bedrock": {
       "command": "python3",
-      "args": ["-m", "semantic_memory.server"],
+      "args": ["-m", "sem_mem.server"],
       "env": {
-        "MEMORY_DB_PATH": "~/.claude/semantic-memory/memory.db",
+        "MEMORY_DB_PATH": "~/.claude/sem-mem/memory.db",
         "EMBEDDING_PROVIDER": "bedrock",
         "LLM_PROVIDER": "bedrock",
         "AWS_PROFILE": "your-sso-profile",
         "AWS_REGION": "us-east-1"
       },
-      "cwd": "/path/to/semantic-memory/src"
+      "cwd": "/path/to/sem-mem/src"
     }
   }
 }

pyproject.toml

@@ -19,14 +19,14 @@ dev = [
 ]
 
 [project.scripts]
-semantic-memory = "semantic_memory.server:main"
+sem-mem = "sem_mem.server:main"
 
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/semantic_memory"]
+packages = ["src/sem_mem"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

scripts/generate_dummy_data.py

@@ -11,9 +11,9 @@
 # Add src to path
 sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
 
-from semantic_memory.embeddings import EmbeddingEngine
-from semantic_memory.models import Frame, Insight
-from semantic_memory.storage import InsightStore
+from sem_mem.embeddings import EmbeddingEngine
+from sem_mem.models import Frame, Insight
+from sem_mem.storage import InsightStore
 
 
 # Template components for generating realistic insights

scripts/setup.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# One-time setup script for the sem-mem MCP server.
+# Usage: bash scripts/setup.sh
+# Safe to run multiple times (idempotent).
+set -euo pipefail
+
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+info()  { printf "${GREEN}[OK]${NC} %s\n" "$1"; }
+warn()  { printf "${YELLOW}[WARN]${NC} %s\n" "$1"; }
+error() { printf "${RED}[ERROR]${NC} %s\n" "$1"; }
+
+# 1. Check for uv, install if missing
+if command -v uv &>/dev/null; then
+  info "uv is already installed ($(uv --version))"
+else
+  warn "uv not found -- installing..."
+  curl -LsSf https://astral.sh/uv/install.sh | sh
+  export PATH="$HOME/.local/bin:$PATH"
+  info "uv installed ($(uv --version))"
+fi
+
+# 2. Install the sem-mem package
+if uv tool list 2>/dev/null | grep -q '^sem-mem '; then
+  info "sem-mem is already installed"
+else
+  echo "Installing sem-mem..."
+  uv tool install sem-mem
+  info "sem-mem installed"
+fi
+
+# 3. Create default DB directory
+DB_DIR="$HOME/.claude/sem-mem"
+mkdir -p "$DB_DIR"
+info "Database directory ready: $DB_DIR"
+
+# 4. Check required environment variables
+MISSING=0
+for var in OPENAI_API_KEY ANTHROPIC_API_KEY; do
+  if [[ -z "${!var:-}" ]]; then
+    warn "Environment variable $var is not set (required for default providers)"
+    MISSING=1
+  else
+    info "$var is set"
+  fi
+done
+
+if [[ "$MISSING" -eq 1 ]]; then
+  echo ""
+  warn "You can skip OPENAI_API_KEY / ANTHROPIC_API_KEY if using Bedrock providers:"
+  echo "  export EMBEDDING_PROVIDER=bedrock"
+  echo "  export LLM_PROVIDER=bedrock"
+  echo "  export AWS_PROFILE=<your-profile>"
+fi
+
+# 5. Summary
+echo ""
+echo "========================================="
+echo " sem-mem setup complete"
+echo "========================================="
+echo ""
+echo "Run the MCP server:"
+echo "  uv tool run sem-mem"
+echo ""
+echo "Or install as a Claude Code plugin:"
+echo "  claude plugin install sem-mem@brainspace"
+echo ""
+echo "Default database location:"
+echo "  $DB_DIR/memory.db"
+echo ""