claude-memory-sync 0.2.0__py3-none-any.whl

claude_memory_sync/merge.py

@@ -0,0 +1,119 @@
+"""Section-aware markdown merge for memory files."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass
+class Section:
+    """A markdown section with a heading and body text."""
+    heading: str  # Empty string for content before first heading
+    body: str
+
+
+def parse_sections(content: str) -> list[Section]:
+    """Parse markdown into sections based on headings (##, ###, etc).
+
+    Content before the first heading becomes a section with heading="".
+    """
+    sections: list[Section] = []
+    current_heading = ""
+    current_lines: list[str] = []
+
+    for line in content.split("\n"):
+        if re.match(r"^#{1,6}\s+", line):
+            # Save previous section
+            sections.append(Section(
+                heading=current_heading,
+                body="\n".join(current_lines),
+            ))
+            current_heading = line
+            current_lines = []
+        else:
+            current_lines.append(line)
+
+    # Save final section
+    sections.append(Section(
+        heading=current_heading,
+        body="\n".join(current_lines),
+    ))
+
+    return sections
+
+
+def deduplicate_bullets(text: str) -> str:
+    """Remove duplicate bullet points, preserving order of first occurrence.
+
+    Only deduplicates lines starting with - or *.
+    Non-bullet lines are always preserved.
+    """
+    seen: set[str] = set()
+    result: list[str] = []
+
+    for line in text.split("\n"):
+        stripped = line.strip()
+        if stripped and (stripped.startswith("- ") or stripped.startswith("* ")):
+            if stripped not in seen:
+                seen.add(stripped)
+                result.append(line)
+        else:
+            result.append(line)
+
+    return "\n".join(result)
+
+
+def merge_sections(
+    local_sections: list[Section], remote_sections: list[Section]
+) -> list[Section]:
+    """Merge two section lists.
+
+    - Sections unique to either side are kept.
+    - Sections with the same heading have their bullets deduplicated and merged.
+    - Order follows local sections first, then any remote-only sections appended.
+    """
+    remote_by_heading = {s.heading: s for s in remote_sections}
+    merged: list[Section] = []
+    seen_headings: set[str] = set()
+
+    for local_sec in local_sections:
+        seen_headings.add(local_sec.heading)
+        remote_sec = remote_by_heading.get(local_sec.heading)
+        if remote_sec is not None:
+            # Merge bodies
+            combined_body = local_sec.body.rstrip("\n") + "\n" + remote_sec.body.lstrip("\n")
+            deduped_body = deduplicate_bullets(combined_body)
+            merged.append(Section(heading=local_sec.heading, body=deduped_body))
+        else:
+            merged.append(local_sec)
+
+    # Append remote-only sections
+    for remote_sec in remote_sections:
+        if remote_sec.heading not in seen_headings:
+            merged.append(remote_sec)
+
+    return merged
+
+
+def _render_sections(sections: list[Section]) -> str:
+    """Render a list of sections back to markdown."""
+    parts: list[str] = []
+    for sec in sections:
+        if sec.heading:
+            parts.append(sec.heading)
+        if sec.body:
+            parts.append(sec.body)
+
+    result = "\n".join(parts)
+    # Clean up excessive blank lines (3+ newlines -> 2)
+    result = re.sub(r"\n{3,}", "\n\n", result)
+    return result.strip() + "\n"
+
+
+def merge_markdown(local_content: str, remote_content: str) -> str:
+    """Full merge pipeline: parse both, merge sections, render back to markdown."""
+    local_sections = parse_sections(local_content)
+    remote_sections = parse_sections(remote_content)
+    merged = merge_sections(local_sections, remote_sections)
+    return _render_sections(merged)

claude_memory_sync/paths.py

@@ -0,0 +1,63 @@
+"""Cross-platform path utilities for Claude memory files."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+
+def get_claude_dir() -> Path:
+    """Return path to ~/.claude/."""
+    return Path.home() / ".claude"
+
+
+def get_projects_dir() -> Path:
+    """Return path to ~/.claude/projects/."""
+    return get_claude_dir() / "projects"
+
+
+def get_config_dir() -> Path:
+    """Return path to ~/.claude-memory-sync/."""
+    return Path.home() / ".claude-memory-sync"
+
+
+def get_state_file() -> Path:
+    """Return path to ~/.claude-memory-sync/state.json."""
+    return get_config_dir() / "state.json"
+
+
+def path_to_project_dirname(path: str) -> str:
+    """Convert a filesystem path to Claude's project directory naming convention.
+
+    Examples:
+        C:\\Users\\ktanm -> "C--Users-ktanm"
+        /Users/ktanm   -> "-Users-ktanm"
+    """
+    # Normalize to forward slashes
+    normalized = path.replace("\\", "/")
+    # Remove trailing slash
+    normalized = normalized.rstrip("/")
+    # Replace colon with dash (Windows drive letter: C: -> C-)
+    normalized = normalized.replace(":", "-")
+    # Replace slashes with dashes
+    return normalized.replace("/", "-")
+
+
+def project_dirname_to_display(dirname: str) -> str:
+    """Convert a Claude project dirname back to a human-readable path.
+
+    Examples:
+        "C--Users-ktanm" -> "C:/Users/ktanm"
+        "-Users-ktanm"   -> "/Users/ktanm"
+    """
+    # Check for Windows-style: starts with a letter followed by --
+    match = re.match(r"^([A-Za-z])--(.*)$", dirname)
+    if match:
+        drive = match.group(1)
+        rest = match.group(2).replace("-", "/")
+        return f"{drive}:/{rest}"
+    # Unix-style: starts with -
+    if dirname.startswith("-"):
+        return dirname.replace("-", "/")
+    # Fallback
+    return dirname.replace("-", "/")

claude_memory_sync/sync_engine.py

@@ -0,0 +1,350 @@
+"""Push/pull/sync orchestration for Claude memory files."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .alias import resolve_alias, resolve_dirname
+from .discovery import discover_projects, get_project_memory_dir
+from .github_api import GitHubAPI, GitHubAPIError
+from .merge import merge_markdown
+from .paths import get_state_file
+
+
+@dataclass
+class SyncResult:
+    """Result of a sync operation."""
+    pushed: list[str] = field(default_factory=list)
+    pulled: list[str] = field(default_factory=list)
+    conflicts: list[str] = field(default_factory=list)
+    skipped: list[str] = field(default_factory=list)
+    errors: list[str] = field(default_factory=list)
+
+
+class SyncEngine:
+    """Orchestrates push/pull/sync of memory files to/from GitHub."""
+
+    def __init__(self, config: dict, api: GitHubAPI):
+        self.config = config
+        self.api = api
+        self.state = self.load_state()
+
+    def load_state(self) -> dict:
+        """Load sync state from state.json."""
+        path = get_state_file()
+        if path.exists():
+            with open(path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        return {}
+
+    def save_state(self) -> None:
+        """Save sync state to state.json."""
+        path = get_state_file()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(self.state, f, indent=2)
+
+    @staticmethod
+    def compute_hash(content: str) -> str:
+        """Compute SHA-256 hex digest of content."""
+        return hashlib.sha256(content.encode("utf-8")).hexdigest()
+
+    def _resolve_alias_for_dirname(self, dirname: str) -> str:
+        """Resolve a project dirname to its alias, or return dirname as-is."""
+        return resolve_alias(dirname)
+
+    def _get_local_dirnames(self, alias: str) -> list[str]:
+        """Get local dirnames for a given alias."""
+        dirnames = resolve_dirname(alias)
+        if dirnames:
+            return dirnames
+        # No alias mapping; treat alias as a raw dirname
+        return [alias]
+
+    def get_local_files(self, alias: str) -> dict[str, str]:
+        """Read all .md files from local memory dirs for the given alias.
+
+        Returns dict of filename -> content.
+        """
+        files: dict[str, str] = {}
+        for dirname in self._get_local_dirnames(alias):
+            memory_dir = get_project_memory_dir(dirname)
+            if not memory_dir.is_dir():
+                continue
+            for md_file in sorted(memory_dir.glob("*.md")):
+                content = md_file.read_text(encoding="utf-8")
+                files[md_file.name] = content
+        return files
+
+    def get_remote_files(self, alias: str) -> dict[str, tuple[str, str]]:
+        """Read all files from GitHub for the given alias.
+
+        Returns dict of filename -> (content, sha).
+        """
+        remote_path = f"projects/{alias}"
+        items = self.api.list_dir(remote_path)
+        files: dict[str, tuple[str, str]] = {}
+        for item in items:
+            if item["type"] == "file" and item["name"].endswith(".md"):
+                data = self.api.get_file(item["path"])
+                if data:
+                    files[item["name"]] = (data["content"], data["sha"])
+        return files
+
+    def _state_key(self, alias: str, filename: str) -> str:
+        return f"{alias}/{filename}"
+
+    def _now_iso(self) -> str:
+        return datetime.now(timezone.utc).isoformat()
+
+    def push(self, alias: str | None = None, dry_run: bool = False) -> SyncResult:
+        """Push local changes to GitHub.
+
+        For each local file, compare hash to state. If changed, upload to GitHub.
+        """
+        result = SyncResult()
+        if alias is None:
+            alias = self._detect_current_alias()
+            if alias is None:
+                result.errors.append("Cannot detect current project. Specify an alias.")
+                return result
+
+        local_files = self.get_local_files(alias)
+        remote_files = self.get_remote_files(alias)
+
+        for filename, content in local_files.items():
+            key = self._state_key(alias, filename)
+            local_hash = self.compute_hash(content)
+            prev_state = self.state.get(key, {})
+            prev_local_hash = prev_state.get("local_hash", "")
+
+            if local_hash == prev_local_hash:
+                result.skipped.append(filename)
+                continue
+
+            # Check for conflict: remote also changed
+            remote_entry = remote_files.get(filename)
+            if remote_entry is not None:
+                remote_content, remote_sha = remote_entry
+                remote_hash = self.compute_hash(remote_content)
+                prev_remote_hash = prev_state.get("remote_hash", "")
+
+                if remote_hash != prev_remote_hash and local_hash != remote_hash:
+                    # Conflict
+                    strategy = self.config.get("conflict_strategy", "merge")
+                    resolved = self.handle_conflict(
+                        filename, content, remote_content, strategy
+                    )
+                    if resolved is None:
+                        result.conflicts.append(filename)
+                        continue
+                    content = resolved
+                    local_hash = self.compute_hash(content)
+                    result.conflicts.append(filename)
+
+            if dry_run:
+                result.pushed.append(filename)
+                continue
+
+            try:
+                remote_path = f"projects/{alias}/{filename}"
+                sha = remote_files[filename][1] if filename in remote_files else None
+                device = self.config.get("device_name", "unknown")
+                self.api.put_file(
+                    remote_path,
+                    content,
+                    f"Sync {filename} from {device}",
+                    sha=sha,
+                )
+                self.state[key] = {
+                    "local_hash": local_hash,
+                    "remote_hash": local_hash,
+                    "last_sync": self._now_iso(),
+                }
+                self.save_state()
+                result.pushed.append(filename)
+            except GitHubAPIError as e:
+                result.errors.append(f"{filename}: {e}")
+
+        return result
+
+    def pull(self, alias: str | None = None, dry_run: bool = False) -> SyncResult:
+        """Pull remote changes to local.
+
+        For each remote file, compare hash to state. If changed, download to local.
+        """
+        result = SyncResult()
+        if alias is None:
+            alias = self._detect_current_alias()
+            if alias is None:
+                result.errors.append("Cannot detect current project. Specify an alias.")
+                return result
+
+        remote_files = self.get_remote_files(alias)
+        local_files = self.get_local_files(alias)
+
+        for filename, (remote_content, remote_sha) in remote_files.items():
+            key = self._state_key(alias, filename)
+            remote_hash = self.compute_hash(remote_content)
+            prev_state = self.state.get(key, {})
+            prev_remote_hash = prev_state.get("remote_hash", "")
+
+            if remote_hash == prev_remote_hash:
+                result.skipped.append(filename)
+                continue
+
+            # Check for conflict: local also changed
+            local_content = local_files.get(filename)
+            if local_content is not None:
+                local_hash = self.compute_hash(local_content)
+                prev_local_hash = prev_state.get("local_hash", "")
+
+                if local_hash != prev_local_hash and local_hash != remote_hash:
+                    strategy = self.config.get("conflict_strategy", "merge")
+                    resolved = self.handle_conflict(
+                        filename, local_content, remote_content, strategy
+                    )
+                    if resolved is None:
+                        result.conflicts.append(filename)
+                        continue
+                    remote_content = resolved
+                    remote_hash = self.compute_hash(remote_content)
+                    result.conflicts.append(filename)
+
+            if dry_run:
+                result.pulled.append(filename)
+                continue
+
+            try:
+                # Write to all local dirnames for this alias
+                for dirname in self._get_local_dirnames(alias):
+                    memory_dir = get_project_memory_dir(dirname)
+                    memory_dir.mkdir(parents=True, exist_ok=True)
+                    target = memory_dir / filename
+                    target.write_text(remote_content, encoding="utf-8")
+
+                self.state[key] = {
+                    "local_hash": remote_hash,
+                    "remote_hash": remote_hash,
+                    "last_sync": self._now_iso(),
+                }
+                self.save_state()
+                result.pulled.append(filename)
+            except OSError as e:
+                result.errors.append(f"{filename}: {e}")
+
+        return result
+
+    def sync(self, alias: str | None = None, dry_run: bool = False) -> SyncResult:
+        """Pull then push. Handle conflicts using config's conflict_strategy."""
+        pull_result = self.pull(alias=alias, dry_run=dry_run)
+        push_result = self.push(alias=alias, dry_run=dry_run)
+
+        return SyncResult(
+            pushed=push_result.pushed,
+            pulled=pull_result.pulled,
+            conflicts=list(set(pull_result.conflicts + push_result.conflicts)),
+            skipped=list(set(pull_result.skipped + push_result.skipped)),
+            errors=pull_result.errors + push_result.errors,
+        )
+
+    def handle_conflict(
+        self,
+        filename: str,
+        local_content: str,
+        remote_content: str,
+        strategy: str,
+    ) -> str | None:
+        """Resolve a conflict between local and remote content.
+
+        Returns resolved content, or None if unresolved (e.g. user chose to skip).
+        """
+        if strategy == "latest-wins":
+            # On push, local wins; caller context determines which
+            return local_content
+        elif strategy == "merge":
+            return merge_markdown(local_content, remote_content)
+        elif strategy == "ask":
+            print(f"\nConflict in {filename}:")
+            print("  [l] Keep local version")
+            print("  [r] Keep remote version")
+            print("  [m] Merge both versions")
+            print("  [s] Skip this file")
+            choice = input("Choice [l/r/m/s]: ").strip().lower()
+            if choice == "l":
+                return local_content
+            elif choice == "r":
+                return remote_content
+            elif choice == "m":
+                return merge_markdown(local_content, remote_content)
+            else:
+                return None
+        else:
+            return merge_markdown(local_content, remote_content)
+
+    def migrate_to_alias(self, old_dirname: str, new_alias: str) -> dict:
+        """Migrate remote data from a raw dirname path to an alias path.
+
+        Copies files from projects/{old_dirname}/ to projects/{new_alias}/,
+        deletes the originals, and updates state keys.
+
+        Returns dict with 'migrated' (list of filenames) and 'errors' (list of str).
+        """
+        result = {"migrated": [], "errors": []}
+        old_path = f"projects/{old_dirname}"
+        items = self.api.list_dir(old_path)
+
+        for item in items:
+            if item["type"] != "file":
+                continue
+            filename = item["name"]
+            try:
+                data = self.api.get_file(item["path"])
+                if data is None:
+                    result["errors"].append(f"{filename}: could not read")
+                    continue
+
+                # Copy to new location
+                new_path = f"projects/{new_alias}/{filename}"
+                existing = self.api.get_file(new_path)
+                sha = existing["sha"] if existing else None
+                self.api.put_file(
+                    new_path,
+                    data["content"],
+                    f"Migrate {filename} from {old_dirname} to {new_alias}",
+                    sha=sha,
+                )
+
+                # Delete from old location
+                self.api.delete_file(
+                    item["path"],
+                    item["sha"],
+                    f"Migrate {filename}: moved to {new_alias}",
+                )
+
+                # Update state keys
+                old_key = self._state_key(old_dirname, filename)
+                new_key = self._state_key(new_alias, filename)
+                if old_key in self.state:
+                    self.state[new_key] = self.state.pop(old_key)
+
+                result["migrated"].append(filename)
+            except GitHubAPIError as e:
+                result["errors"].append(f"{filename}: {e}")
+
+        if result["migrated"]:
+            self.save_state()
+
+        return result
+
+    def _detect_current_alias(self) -> str | None:
+        """Detect alias for the current working directory's project."""
+        from .discovery import get_current_project
+        dirname = get_current_project()
+        if dirname is None:
+            return None
+        return self._resolve_alias_for_dirname(dirname)

claude_memory_sync-0.2.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: claude-memory-sync
+Version: 0.2.0
+Summary: Sync Claude Code memory files across machines via GitHub
+Author-email: Tanmay Kallakuri <tanmay@users.noreply.github.com>
+License: MIT
+Project-URL: Homepage, https://github.com/TanmayKallakuri/claude-memory-sync
+Project-URL: Repository, https://github.com/TanmayKallakuri/claude-memory-sync
+Project-URL: Issues, https://github.com/TanmayKallakuri/claude-memory-sync/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Version Control
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Dynamic: license-file
+
+# claude-memory-sync
+
+Sync Claude Code memory files across machines via GitHub.
+
+Claude Code stores per-project memory in `~/.claude/projects/<dirname>/memory/`. This tool syncs those files to a private GitHub repo so your memory follows you across devices.
+
+## Install
+
+```bash
+pip install claude-memory-sync
+```
+
+## Quickstart
+
+```bash
+# 1. Run setup (needs gh CLI authenticated or a GitHub token)
+claude-memory setup
+
+# 2. Push your local memory to GitHub
+claude-memory push
+
+# 3. Pull memory on another machine
+claude-memory pull
+
+# 4. Bidirectional sync (pull then push)
+claude-memory sync
+```
+
+## Cross-Device Setup
+
+Different machines encode project paths differently (`C--Users-ktanm` on Windows vs `-Users-ktanm` on Mac). Aliases map these to a shared name so syncing works seamlessly.
+
+```bash
+# Auto-create aliases from matching project names
+claude-memory alias auto
+
+# Or manually add an alias
+claude-memory alias add home --dirname C--Users-ktanm
+
+# See what aliases exist
+claude-memory alias list
+
+# Sync aliases to/from remote
+claude-memory alias sync
+```
+
+When you run `claude-memory setup` on a new device, the setup wizard will automatically discover remote projects and let you map them to local ones.
+
+### Migrating Existing Data
+
+If you already pushed data under a raw dirname and want to consolidate under an alias:
+
+```bash
+claude-memory alias migrate --dirname C--Users-ktanm --alias home
+```
+
+## Auto-Sync with Claude Code Hooks
+
+Install hooks so memory syncs automatically when Claude Code sessions start and stop:
+
+```bash
+# Install hooks into ~/.claude/settings.json
+claude-memory hooks install
+
+# Remove hooks
+claude-memory hooks remove
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `setup` | Interactive setup wizard |
+| `push` | Upload local memory to GitHub |
+| `pull` | Download memory from GitHub |
+| `sync` | Bidirectional sync (pull then push) |
+| `alias` | Manage project aliases (add, remove, list, suggest, auto, sync, migrate) |
+| `hooks` | Install/remove Claude Code auto-sync hooks |
+| `status` | Show configuration and sync state |
+| `doctor` | Diagnose configuration issues |
+
+All sync commands support `--dry-run` and `--project <alias>` flags.
+
+## Configuration
+
+Config is stored at `~/.claude-memory-sync/config.json`:
+
+- **device_name**: Identifier for this machine
+- **github_repo**: GitHub repo in `owner/repo` format
+- **conflict_strategy**: How to handle conflicts (`merge`, `latest-wins`, or `ask`)
+
+GitHub token is resolved from (in order):
+1. `CLAUDE_MEMORY_SYNC_TOKEN` env var
+2. `GH_TOKEN` env var
+3. `gh auth token` CLI
+
+## License
+
+MIT

claude_memory_sync-0.2.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+claude_memory_sync/__init__.py,sha256=DmZ3Ae9kQVFmYHuZvtCxse4uksTIlvj4k_SF-K5zChw,111
+claude_memory_sync/__main__.py,sha256=MeDq0gFkTbSEU8bnTZLoM5jiNjXqFqoiMCbB-jnJCWM,91
+claude_memory_sync/alias.py,sha256=0WVwm2OPAn2wIjnGvUT6q2jWTXPV55ZbKDfgrUflZxY,3950
+claude_memory_sync/cli.py,sha256=T2nEPp5ehSuYxDCyyvvQkWQCQ_VSTScVNpjpE1KXNew,16662
+claude_memory_sync/config.py,sha256=fWsvtirOhTek3odwbuKepSQoj40kNQw2sbJZZOadu4o,7744
+claude_memory_sync/discovery.py,sha256=w4yg0FWzvoLAvQGLBlxPFD72EnYfngcRdzqWDzcbE-M,1781
+claude_memory_sync/github_api.py,sha256=pgfhwmY1NDikjJ1DCl9zkmBo06WQlIIGt49wcwZFt9c,4801
+claude_memory_sync/hooks.py,sha256=y7pT1H7vKDKg5NtjKgjLcGcJCDK8IgFIJt5TmgztTFY,6485
+claude_memory_sync/merge.py,sha256=_DGaaSyQyUmpGVdB_CllL_-kc_Xo7thohtlqYSMd8gw,3826
+claude_memory_sync/paths.py,sha256=xvLxnw9m8CZBFXALBUS265y3WrepGZH-fbLz08jj49E,1891
+claude_memory_sync/sync_engine.py,sha256=81EY3ee4efQLRyS4oJGT-3JuHapWKfsHhY6cu7aGRyo,13796
+claude_memory_sync-0.2.0.dist-info/licenses/LICENSE,sha256=_L5S7aSvaX2O38w3pWYfGL_EamTm_G41yXrsREH9Dms,1073
+claude_memory_sync-0.2.0.dist-info/METADATA,sha256=vWvuVUkGAKqzNDMafUHt2dBWpjuXPINJNoXg3pAObjw,3879
+claude_memory_sync-0.2.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+claude_memory_sync-0.2.0.dist-info/entry_points.txt,sha256=69fA-2Ui742r-ESdZ4XXWKFwTdpDW_Ul3rQNADTjI7k,194
+claude_memory_sync-0.2.0.dist-info/top_level.txt,sha256=p4NXBnT6stW89-zuTdaPiKz_GG22vi3tw_JqDkWp_5c,19
+claude_memory_sync-0.2.0.dist-info/RECORD,,

claude_memory_sync-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

claude_memory_sync-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+claude-memory = claude_memory_sync.cli:main
+claude-memory-hook-pull = claude_memory_sync.hooks:hook_auto_pull
+claude-memory-hook-push = claude_memory_sync.hooks:hook_auto_push