crossmem 0.1.0__tar.gz

crossmem-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Md Niajul Hasan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

crossmem-0.1.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: crossmem
+Version: 0.1.0
+Summary: Cross-project memory for AI coding agents
+Keywords: ai,memory,mcp,developer-tools,cross-project
+Author: Md Niajul Hasan
+Author-email: Md Niajul Hasan <niajul1992@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: click>=8.0
+Requires-Dist: mcp>=1.27.0
+Requires-Dist: pytest>=8.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.4 ; extra == 'dev'
+Requires-Python: >=3.12
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# crossmem
+
+Your AI assistant remembers everything you've ever solved — across every project and every tool.
+
+## The problem
+
+You're working on project B. You need credential masking. You know you solved this in project A three months ago — but your AI assistant has no idea. It starts from scratch, suggests a different approach, and you waste an hour getting back to where you already were.
+
+Here's what's happening under the hood:
+
+```
+~/.claude/projects/
+├── project-A/memory/MEMORY.md    ← Claude remembers here
+├── project-B/memory/MEMORY.md    ← ...but can't see here
+└── project-C/memory/MEMORY.md    ← ...or here
+
+~/.gemini/GEMINI.md               ← Gemini's memories (separate silo entirely)
+```
+
+Every project is a silo. Every tool is a silo. Knowledge doesn't compound — it resets.
+
+## The fix
+
+```bash
+$ crossmem ingest
+Ingested: 298 memories across 10 projects (Claude Code + Gemini CLI)
+
+$ crossmem search "credential masking"
+Found 3 results for "credential masking":
+
+[1] project-A / Security
+    Source: MEMORY.md
+    - Credentials masked in experience_memory before persisting (_mask_actions)...
+
+[2] project-B / Security
+    Source: MEMORY.md
+    - Credentials masked via _mask_context_credentials() + _mask_text()...
+
+[3] project-A / Security
+    Source: GEMINI.md
+    - Credential masking pattern: _mask_actions for persistence, _mask_text for logs...
+```
+
+Three results. Two projects. Two AI tools. One query. The pattern was already solved — twice.
+
+> Unlike Mem0 (cloud-based, API-key required) or Basic Memory (single-tool), crossmem is local-only, zero-config, and aggregates across both tools and projects.
+
+## Install
+
+```bash
+pip install crossmem
+# or
+uv pip install crossmem
+```
+
+## Quick start
+
+```bash
+pip install crossmem        # 1. Install
+crossmem ingest             # 2. Index all your AI memories
+crossmem search "retry"     # 3. Search across every project
+```
+
+That's it. Three commands, zero config. crossmem finds Claude Code and Gemini CLI memory files automatically.
+
+To give your AI tools direct access, add the MCP server to your config (see [MCP Server](#mcp-server) below) — then `mem_recall()` and `mem_search()` just work inside your coding sessions.
+
+## Usage
+
+```bash
+# Ingest Claude Code + Gemini CLI memories
+crossmem ingest
+
+# Search across every project
+crossmem search "JWT token rotation"
+crossmem search "retry strategy" -p backend-api
+crossmem search "docker compose" -n 5
+
+# Sync Claude memories → Gemini CLI
+crossmem sync                        # sync everything
+crossmem sync -p backend-api        # sync one project + shared patterns
+
+# Watch for changes and auto-sync
+crossmem sync-watch                  # polls every 30s
+crossmem sync-watch --interval 10    # custom interval
+
+# Visualize the knowledge graph
+crossmem graph
+
+# See what's in the database
+crossmem stats
+```
+
+## How it works
+
+1. **Ingest** — Reads Claude Code (`~/.claude/projects/*/memory/*.md`) and Gemini CLI (`~/.gemini/GEMINI.md`), splits into granular chunks, deduplicates by content hash
+2. **Index** — Stores in SQLite with FTS5 full-text search (porter stemming + unicode61 tokenizer)
+3. **Search** — Multi-word queries use AND logic by default. Quoted phrases for exact matches
+4. **Learn** — AI tools save new discoveries via `mem_save` during sessions. Knowledge compounds automatically
+5. **Sync** — Translates Claude's structured markdown into Gemini's flat bullet format, preserving each tool's own memories
+
+## MCP Server
+
+crossmem runs as an MCP server so AI coding tools can search, recall, and save memories in real-time.
+
+### Setup
+
+Add to your tool's MCP config:
+
+**Claude Code** (`~/.mcp.json` for global, or `.mcp.json` in project root):
+```json
+{
+  "mcpServers": {
+    "crossmem": {
+      "command": "crossmem-server"
+    }
+  }
+}
+```
+
+**Gemini CLI** (`~/.gemini/settings.json`):
+```json
+{
+  "mcpServers": {
+    "crossmem": {
+      "command": "crossmem-server"
+    }
+  }
+}
+```
+
+> **Note:** If `crossmem-server` isn't on PATH, use:
+> `"command": "uvx", "args": ["--from", "crossmem", "crossmem-server"]`
+
+### Tools
+
+| Tool | Description |
+|------|-------------|
+| `mem_recall` | Load project context + cross-project patterns at session start (auto-detects project from cwd) |
+| `mem_search` | Search across all memories (query, project filter, limit) |
+| `mem_save` | Save a discovery during a session — immediately searchable |
+| `mem_ingest` | Refresh the index when memory files change |
+
+### Start manually
+
+```bash
+crossmem serve    # starts MCP server on stdio
+```
+
+## Supported tools
+
+| Tool | Ingestion |
+|------|-----------|
+| Claude Code | `~/.claude/projects/*/memory/*.md` |
+| Gemini CLI | `~/.gemini/GEMINI.md` |
+
+Ingestion is pluggable — PRs welcome for new tools.
+
+## License
+
+MIT

crossmem-0.1.0/README.md

@@ -0,0 +1,161 @@
+# crossmem
+
+Your AI assistant remembers everything you've ever solved — across every project and every tool.
+
+## The problem
+
+You're working on project B. You need credential masking. You know you solved this in project A three months ago — but your AI assistant has no idea. It starts from scratch, suggests a different approach, and you waste an hour getting back to where you already were.
+
+Here's what's happening under the hood:
+
+```
+~/.claude/projects/
+├── project-A/memory/MEMORY.md    ← Claude remembers here
+├── project-B/memory/MEMORY.md    ← ...but can't see here
+└── project-C/memory/MEMORY.md    ← ...or here
+
+~/.gemini/GEMINI.md               ← Gemini's memories (separate silo entirely)
+```
+
+Every project is a silo. Every tool is a silo. Knowledge doesn't compound — it resets.
+
+## The fix
+
+```bash
+$ crossmem ingest
+Ingested: 298 memories across 10 projects (Claude Code + Gemini CLI)
+
+$ crossmem search "credential masking"
+Found 3 results for "credential masking":
+
+[1] project-A / Security
+    Source: MEMORY.md
+    - Credentials masked in experience_memory before persisting (_mask_actions)...
+
+[2] project-B / Security
+    Source: MEMORY.md
+    - Credentials masked via _mask_context_credentials() + _mask_text()...
+
+[3] project-A / Security
+    Source: GEMINI.md
+    - Credential masking pattern: _mask_actions for persistence, _mask_text for logs...
+```
+
+Three results. Two projects. Two AI tools. One query. The pattern was already solved — twice.
+
+> Unlike Mem0 (cloud-based, API-key required) or Basic Memory (single-tool), crossmem is local-only, zero-config, and aggregates across both tools and projects.
+
+## Install
+
+```bash
+pip install crossmem
+# or
+uv pip install crossmem
+```
+
+## Quick start
+
+```bash
+pip install crossmem        # 1. Install
+crossmem ingest             # 2. Index all your AI memories
+crossmem search "retry"     # 3. Search across every project
+```
+
+That's it. Three commands, zero config. crossmem finds Claude Code and Gemini CLI memory files automatically.
+
+To give your AI tools direct access, add the MCP server to your config (see [MCP Server](#mcp-server) below) — then `mem_recall()` and `mem_search()` just work inside your coding sessions.
+
+## Usage
+
+```bash
+# Ingest Claude Code + Gemini CLI memories
+crossmem ingest
+
+# Search across every project
+crossmem search "JWT token rotation"
+crossmem search "retry strategy" -p backend-api
+crossmem search "docker compose" -n 5
+
+# Sync Claude memories → Gemini CLI
+crossmem sync                        # sync everything
+crossmem sync -p backend-api        # sync one project + shared patterns
+
+# Watch for changes and auto-sync
+crossmem sync-watch                  # polls every 30s
+crossmem sync-watch --interval 10    # custom interval
+
+# Visualize the knowledge graph
+crossmem graph
+
+# See what's in the database
+crossmem stats
+```
+
+## How it works
+
+1. **Ingest** — Reads Claude Code (`~/.claude/projects/*/memory/*.md`) and Gemini CLI (`~/.gemini/GEMINI.md`), splits into granular chunks, deduplicates by content hash
+2. **Index** — Stores in SQLite with FTS5 full-text search (porter stemming + unicode61 tokenizer)
+3. **Search** — Multi-word queries use AND logic by default. Quoted phrases for exact matches
+4. **Learn** — AI tools save new discoveries via `mem_save` during sessions. Knowledge compounds automatically
+5. **Sync** — Translates Claude's structured markdown into Gemini's flat bullet format, preserving each tool's own memories
+
+## MCP Server
+
+crossmem runs as an MCP server so AI coding tools can search, recall, and save memories in real-time.
+
+### Setup
+
+Add to your tool's MCP config:
+
+**Claude Code** (`~/.mcp.json` for global, or `.mcp.json` in project root):
+```json
+{
+  "mcpServers": {
+    "crossmem": {
+      "command": "crossmem-server"
+    }
+  }
+}
+```
+
+**Gemini CLI** (`~/.gemini/settings.json`):
+```json
+{
+  "mcpServers": {
+    "crossmem": {
+      "command": "crossmem-server"
+    }
+  }
+}
+```
+
+> **Note:** If `crossmem-server` isn't on PATH, use:
+> `"command": "uvx", "args": ["--from", "crossmem", "crossmem-server"]`
+
+### Tools
+
+| Tool | Description |
+|------|-------------|
+| `mem_recall` | Load project context + cross-project patterns at session start (auto-detects project from cwd) |
+| `mem_search` | Search across all memories (query, project filter, limit) |
+| `mem_save` | Save a discovery during a session — immediately searchable |
+| `mem_ingest` | Refresh the index when memory files change |
+
+### Start manually
+
+```bash
+crossmem serve    # starts MCP server on stdio
+```
+
+## Supported tools
+
+| Tool | Ingestion |
+|------|-----------|
+| Claude Code | `~/.claude/projects/*/memory/*.md` |
+| Gemini CLI | `~/.gemini/GEMINI.md` |
+
+Ingestion is pluggable — PRs welcome for new tools.
+
+## License
+
+MIT

crossmem-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[project]
+name = "crossmem"
+version = "0.1.0"
+description = "Cross-project memory for AI coding agents"
+readme = "README.md"
+authors = [
+    { name = "Md Niajul Hasan", email = "niajul1992@gmail.com" }
+]
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["ai", "memory", "mcp", "developer-tools", "cross-project"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "click>=8.0",
+    "mcp>=1.27.0",
+]
+
+[project.scripts]
+crossmem = "crossmem.cli:main"
+crossmem-server = "crossmem.server:main"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "ruff>=0.4",
+]
+
+[build-system]
+requires = ["uv_build>=0.10.10,<0.11.0"]
+build-backend = "uv_build"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W", "UP"]
+
+[tool.ruff.lint.per-file-ignores]
+"src/crossmem/graph.py" = ["E501"]  # HTML/JS template has long lines
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

crossmem-0.1.0/src/crossmem/__init__.py

@@ -0,0 +1,3 @@
+"""Cross-project memory for AI coding agents."""
+
+__version__ = "0.1.0"

crossmem-0.1.0/src/crossmem/cli.py

@@ -0,0 +1,125 @@
+"""CLI interface for crossmem."""
+
+import click
+
+from crossmem.ingest import ingest_claude_memory, ingest_gemini_memory
+from crossmem.store import DEFAULT_DB_PATH, MemoryStore
+
+
+@click.group()
+@click.version_option()
+def main() -> None:
+    """Cross-project memory for AI coding agents."""
+
+
+@main.command()
+def ingest() -> None:
+    """Ingest memory files from AI coding tools."""
+    store = MemoryStore()
+    try:
+        click.echo("Ingesting Claude Code memories...")
+        added = ingest_claude_memory(store)
+        click.echo("Ingesting Gemini CLI memories...")
+        added += ingest_gemini_memory(store)
+        total = store.count()
+        stats = store.stats()
+
+        click.echo(f"\nAdded {added} new memories ({total} total)")
+        click.echo(f"Database: {DEFAULT_DB_PATH}")
+        click.echo(f"\nProjects ({len(stats)}):")
+        for project, count in stats.items():
+            click.echo(f"  {project}: {count} memories")
+    finally:
+        store.close()
+
+
+@main.command()
+@click.argument("query")
+@click.option("-p", "--project", default=None, help="Filter by project name")
+@click.option("-n", "--limit", default=10, help="Max results")
+def search(query: str, project: str | None, limit: int) -> None:
+    """Search across all project memories."""
+    store = MemoryStore()
+    try:
+        results = store.search(query, limit=limit, project=project)
+
+        if not results:
+            click.echo(f'No results for "{query}"')
+            return
+
+        click.echo(f'Found {len(results)} results for "{query}":\n')
+        for i, result in enumerate(results, 1):
+            mem = result.memory
+            click.echo(f"[{i}] {mem.project} / {mem.section or '(root)'}")
+            click.echo(f"    Source: {mem.source_file.split('/')[-1]}")
+            click.echo(f"    {mem.snippet}")
+            click.echo()
+    finally:
+        store.close()
+
+
+@main.command()
+@click.option("--port", default=8765, help="Port for local server")
+def graph(port: int) -> None:
+    """Visualize the knowledge graph in your browser."""
+    from crossmem.graph import serve_graph
+
+    store = MemoryStore()
+    if store.count() == 0:
+        click.echo("No memories yet. Run: crossmem ingest")
+        store.close()
+        return
+    serve_graph(store, port=port)  # closes store internally before serving
+
+
+@main.command()
+@click.option("-p", "--project", default=None, help="Sync this project + shared patterns")
+def sync(project: str | None) -> None:
+    """Sync Claude Code memories → Gemini CLI (one-shot)."""
+    from crossmem.sync import sync_once
+
+    count, changed = sync_once(project=project)
+    if changed:
+        label = f"{project} + shared patterns" if project else "all"
+        click.echo(f"Synced {count} memories ({label}) → ~/.gemini/GEMINI.md")
+    else:
+        click.echo(f"Already in sync ({count} memories)")
+
+
+@main.command(name="sync-watch")
+@click.option("--interval", default=30, help="Poll interval in seconds")
+@click.option("-p", "--project", default=None, help="Sync this project + shared patterns")
+def sync_watch(interval: int, project: str | None) -> None:
+    """Watch Claude memories and sync to Gemini on changes."""
+    from crossmem.sync import watch
+
+    watch(interval=interval, project=project)
+
+
+@main.command()
+def serve() -> None:
+    """Start the MCP server (stdio transport)."""
+    from crossmem.server import main as serve_main
+
+    serve_main()
+
+
+@main.command()
+def stats() -> None:
+    """Show memory statistics."""
+    store = MemoryStore()
+    try:
+        total = store.count()
+        projects = store.stats()
+
+        if total == 0:
+            click.echo("No memories yet. Run: crossmem ingest")
+            return
+
+        click.echo(f"Total memories: {total}")
+        click.echo(f"Projects: {len(projects)}\n")
+        for project, count in projects.items():
+            click.echo(f"  {project}: {count}")
+        click.echo(f"\nDatabase: {DEFAULT_DB_PATH}")
+    finally:
+        store.close()