carrymem 0.1.2__py3-none-any.whl

carrymem-0.1.2.dist-info/METADATA

@@ -0,0 +1,433 @@
+Metadata-Version: 2.4
+Name: carrymem
+Version: 0.1.2
+Summary: Your portable AI memory layer. Classify, store, and recall what matters across models, tools, and devices.
+Home-page: https://github.com/lulin70/carrymem
+Author: lulin70
+Author-email: lulin70@gmail.com
+License: MIT
+Keywords: ai memory classification mcp agent persistence portable
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML>=5.0
+Provides-Extra: language
+Requires-Dist: pycld2>=0.41; extra == "language"
+Requires-Dist: langdetect>=1.0.9; extra == "language"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.10; extra == "dev"
+Requires-Dist: coverage[toml]>=7.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0; extra == "dev"
+Requires-Dist: build>=0.10; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Requires-Dist: pycld2>=0.41; extra == "dev"
+Requires-Dist: langdetect>=1.0.9; extra == "dev"
+Requires-Dist: flake8>=6.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: isort>=5.12; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Provides-Extra: encryption
+Requires-Dist: cryptography>=41.0; extra == "encryption"
+Provides-Extra: tui
+Requires-Dist: textual>=0.40; extra == "tui"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# CarryMem — The Identity Layer for AI
+
+**AI remembers who you are. Not just what you said.**
+
+> Your portable AI identity layer — preferences, decisions, and corrections that follow you across models, tools, and devices.
+
+CarryMem is a lightweight, zero-dependency AI memory system that stores **who you are** — your preferences, decisions, corrections — and makes that identity available to any AI tool. Switch from Cursor to Claude Code, from GPT to Claude, your AI always knows you.
+
+**English** | [中文](docs/i18n/README-CN.md) | [日本語](docs/i18n/README-JP.md)
+
+<p align="center">
+  <img src="https://img.shields.io/badge/version-0.1.2-blue" alt="Version">
+  <img src="https://img.shields.io/badge/tests-490%20passing-green" alt="Tests">
+  <img src="https://img.shields.io/badge/coverage-61%25-yellow" alt="Coverage">
+  <img src="https://img.shields.io/badge/accuracy-90.6%25-green" alt="Accuracy">
+  <img src="https://img.shields.io/badge/zero--dependencies-core-brightgreen" alt="Zero Deps">
+</p>
+
+---
+
+## Why CarryMem?
+
+### The Problem: AI Always Forgets Who You Are
+
+Every new conversation, AI starts from zero:
+- You prefer dark mode? **Forgotten.**
+- You corrected it last time? **Forgotten.**
+- You decided to use React? **Forgotten.**
+
+Switch tools (Cursor → Windsurf), switch models (Claude → GPT) — start from scratch every time.
+
+### The Solution: CarryMem Identity Layer
+
+CarryMem doesn't just store text — it understands **who you are**:
+
+```bash
+$ carrymem whoami
+
+  Who You Are (according to your AI)
+  ==================================================
+
+  Your Preferences:
+    ⭐ I prefer dark mode for all editors
+    ⭐ I use PostgreSQL for databases
+    ⭐ I always use Python for data analysis
+
+  Your Decisions:
+    🎯 Let's use React for the frontend
+
+  Your Corrections:
+    🔧 The port should be 5432, not 3306
+
+  Memory Profile:
+    Total: 19 | Dominant: user_preference | Avg Confidence: 73%
+```
+
+---
+
+## Quick Start
+
+### Install
+
+```bash
+pip install -e .
+```
+
+### 5 Lines of Code
+
+```python
+from memory_classification_engine import CarryMem
+
+cm = CarryMem()
+cm.classify_and_remember("I prefer dark mode")        # Auto-classified as preference
+cm.classify_and_remember("Use PostgreSQL not MySQL")   # Auto-classified as correction
+memories = cm.recall_memories("database")              # Semantic recall
+print(cm.build_system_prompt())                        # Inject into any AI
+cm.close()
+```
+
+### CLI (19 commands)
+
+```bash
+carrymem init                           # Initialize
+carrymem add "I prefer dark mode"       # Store a memory
+carrymem add "test note" --force        # Force store (bypass classification)
+carrymem list                           # List memories
+carrymem search "theme"                 # Search memories
+carrymem show <key>                     # View memory details
+carrymem edit <key> "new content"       # Edit a memory
+carrymem forget <key>                   # Delete a memory
+carrymem whoami                         # Who your AI thinks you are
+carrymem profile export identity.json   # Export your AI identity
+carrymem stats                          # Memory statistics
+carrymem check                          # Quality & conflict check
+carrymem clean --expired --dry-run      # Preview cleanup
+carrymem doctor                         # Diagnose installation
+carrymem setup-mcp --tool cursor        # One-line MCP config
+carrymem tui                            # Terminal UI
+carrymem export backup.json             # Export all memories
+carrymem import backup.json             # Import memories
+carrymem version                        # Show version
+```
+
+---
+
+## Core Features
+
+### 1. Auto-Classification (7 Memory Types)
+
+CarryMem automatically identifies what kind of information you're sharing:
+
+| Type | Icon | Example |
+|------|------|---------|
+| `user_preference` | ⭐ | "I prefer dark mode" |
+| `correction` | 🔧 | "No, I meant Python 3.11 not 3.10" |
+| `decision` | 🎯 | "Let's use React for the frontend" |
+| `fact_declaration` | 📌 | "Python 3.12 is the runtime version" |
+| `relationship` | ❓ | "Sarah is my manager" |
+| `task_pattern` | 🔄 | "I always write tests first" |
+| `sentiment_marker` | 💭 | "This build is too slow" |
+
+### 2. Semantic Recall (Cross-Language)
+
+```python
+cm.classify_and_remember("我偏好使用PostgreSQL")
+
+# All of these find it:
+cm.recall_memories("PostgreSQL")     # Exact match
+cm.recall_memories("数据库")          # Synonym expansion
+cm.recall_memories("Postgres")       # Spell correction
+cm.recall_memories("データベース")    # Cross-language (Japanese)
+```
+
+### 3. Identity Layer (whoami)
+
+```python
+identity = cm.whoami()
+print(identity["preferences"])   # ["I prefer dark mode", ...]
+print(identity["decisions"])     # ["Let's use React", ...]
+print(identity["corrections"])   # ["The port should be 5432", ...]
+```
+
+### 4. Importance Scoring & Lifecycle
+
+Every memory has an importance score that evolves over time:
+
+```
+importance = confidence × type_weight × recency_factor × access_factor
+```
+
+- **30-day half-life decay** — old memories fade unless accessed
+- **Access reinforcement** — frequently recalled memories stay fresh
+- **Type weighting** — corrections (1.3x) > decisions (1.2x) > preferences (1.1x)
+
+### 5. Quality Management
+
+```bash
+carrymem check                    # Check all
+carrymem check --conflicts        # Detect contradictions
+carrymem check --quality          # Find low-quality memories
+carrymem check --expired          # Find expired memories
+carrymem clean --expired --dry-run # Preview cleanup
+```
+
+### 6. Security & Reliability
+
+| Feature | Description |
+|---------|-------------|
+| **Encryption** | AES-128 (Fernet) or HMAC-CTR fallback, zero-dep |
+| **Backup** | Zero-downtime SQLite VACUUM INTO |
+| **Audit Log** | Append-only operation history |
+| **Version History** | Every edit tracked, rollback supported |
+| **Input Validation** | SQL injection, XSS, path traversal protection |
+
+### 7. MCP Integration (One-Line Setup)
+
+```bash
+# Configure for Cursor
+carrymem setup-mcp --tool cursor
+
+# Configure for Claude Code
+carrymem setup-mcp --tool claude-code
+
+# Configure for all
+carrymem setup-mcp --tool all
+```
+
+12 MCP tools available: Core (3) · Storage (3) · Knowledge (3) · Profile (2) · Prompt (1)
+
+### 8. Terminal UI
+
+```bash
+pip install textual
+carrymem tui
+```
+
+Interactive terminal interface with sidebar filters, search, and add mode.
+
+---
+
+## Comparison
+
+|  | CarryMem | Mem0 | OpenChronicle | ima |
+|--|----------|------|---------------|-----|
+| **Zero Dependencies** | ✅ SQLite only | ❌ Milvus needed | ✅ | ❌ Cloud |
+| **Auto-Classification** | ✅ 7 types | ❌ | ❌ Manual | ❌ |
+| **Identity Portrait** | ✅ whoami | ❌ | ❌ | ❌ |
+| **CLI** | ✅ 19 commands | ❌ | ❌ | ❌ |
+| **TUI** | ✅ textual | ❌ | ❌ | ✅ App |
+| **Encryption** | ✅ Built-in | ❌ | ❌ | ❌ |
+| **Version History** | ✅ Rollback | ❌ | ❌ | ❌ |
+| **Conflict Detection** | ✅ Built-in | ❌ | ❌ | ❌ |
+| **Data Ownership** | ✅ Local files | ⚠️ Cloud | ✅ Local | ❌ Cloud |
+| **5-Line Integration** | ✅ | ❌ | ❌ | ❌ |
+| **Cross-Language Recall** | ✅ EN/CN/JP | ❌ | ❌ | ❌ |
+
+**Key Difference**: Other products store *what you read*. CarryMem stores *who you are*.
+
+---
+
+## Performance
+
+| Metric | Value |
+|--------|-------|
+| Classification Accuracy | **90.6%** |
+| F1 Score | **97.9%** |
+| Zero-Cost Classification | **60%+** |
+| Recall Latency (P50) | **~45ms** |
+| Tests Passing | **507/507** |
+| Test Coverage | **62.54%** |
+
+---
+
+## Architecture
+
+```
+User Input
+    ↓
+Auto-Classification (7 types, 4 tiers)
+    ↓
+Importance Scoring (confidence × type × recency × access)
+    ↓
+Smart Storage (SQLite + FTS5, dedup, TTL, encryption)
+    ↓
+Semantic Recall (FTS5 + synonyms + spell fix + cross-language)
+    ↓
+Context Injection (token budget, relevance ranking)
+    ↓
+AI Tool (Cursor / Claude Code / any MCP client)
+```
+
+**Three-Tier Classification**:
+```
+Rule Engine (60%+) → Pattern Analysis (30%) → Semantic (10%)
+     ↓                      ↓                      ↓
+ Zero cost            Near-zero cost          Token cost
+```
+
+---
+
+## Advanced Usage
+
+### Obsidian Knowledge Base
+
+```python
+from memory_classification_engine import CarryMem, ObsidianAdapter
+
+cm = CarryMem(knowledge_adapter=ObsidianAdapter("/path/to/vault"))
+cm.index_knowledge()
+results = cm.recall_from_knowledge("Python design patterns")
+```
+
+### Async API
+
+```python
+from memory_classification_engine import AsyncCarryMem
+
+async with AsyncCarryMem() as cm:
+    await cm.classify_and_remember("I prefer dark mode")
+    memories = await cm.recall_memories("theme")
+```
+
+### JSON Adapter (No SQLite)
+
+```python
+from memory_classification_engine import CarryMem, JSONAdapter
+
+cm = CarryMem(adapter=JSONAdapter("/path/to/memories.json"))
+```
+
+### Encryption
+
+```python
+cm = CarryMem(encryption_key="my-secret-key")
+# All content encrypted at rest, decrypted on read
+```
+
+### Memory Versioning
+
+```python
+cm.update_memory(key, "Updated content")     # Creates version 2
+history = cm.get_memory_history(key)          # [v1, v2]
+cm.rollback_memory(key, version=1)            # Restore v1
+```
+
+### Export Identity for Other AIs
+
+```python
+# Export your AI identity
+cm.export_profile(output_path="my_identity.json")
+
+# On another device or AI tool
+cm.import_memories(input_path="backup.json")
+```
+
+---
+
+## Documentation
+
+- [Quick Start Guide](docs/QUICK_START_GUIDE.md)
+- [Architecture](docs/ARCHITECTURE.md)
+- [API Reference](docs/API_REFERENCE.md)
+- [User Stories](docs/USER_STORIES.md)
+- [Roadmap](docs/ROADMAP.md)
+- [Contributing](CONTRIBUTING.md)
+
+---
+
+## Who Is This For?
+
+**Developers** — Building AI agents that need to remember users across sessions
+
+**Power Users** — Want AI tools (Cursor, Claude Code, Windsurf) to remember them
+
+**Teams** — Share organizational knowledge through shared memory namespaces
+
+---
+
+## Project Status
+
+**Current Version**: v0.1.2
+**Tests**: 507/507 passing
+**Coverage**: 62.54%
+**Accuracy**: 90.6%
+
+**v0.8.x Changelog**:
+- v0.1.2: Identity layer (whoami, profile export), competitive differentiation
+- v0.8.1: User-perspective CLI improvements (show/edit/clean, color output, --force)
+- v0.8.0: Enhanced CLI (19 commands), TUI, MCP setup, doctor, quality management
+- v0.7.0: MCP HTTP/SSE, JSON adapter, async API
+- v0.6.0: Encryption, backup, audit logging
+- v0.5.0: Smart context injection, importance scoring, cache, merge, versioning
+
+---
+
+## Contributing
+
+```bash
+git clone https://github.com/lulin70/carrymem.git
+cd carrymem
+pip install -e ".[dev]"
+pytest
+```
+
+See [Contributing Guide](CONTRIBUTING.md) for details.
+
+---
+
+## License
+
+MIT License — see [LICENSE](LICENSE)
+
+---
+
+**CarryMem — AI remembers who you are. Only you own the data.** 🚀

carrymem-0.1.2.dist-info/RECORD

@@ -0,0 +1,63 @@
+carrymem-0.1.2.dist-info/licenses/LICENSE,sha256=IyQ8KJWiNHXfkWd0NFq2g7V_7QOBZOrheFxBxPkPCls,1069
+memory_classification_engine/__init__.py,sha256=pirWlJtwGNERFITLN4eCKO0d5HD6qDQtnLtmIP1-dgU,2376
+memory_classification_engine/__main__.py,sha256=Gc-2tcJQ85nFX9_njHjzrSlxIx62rLtTYH2ewJx_Spo,3466
+memory_classification_engine/__version__.py,sha256=YvuYzWnKtqBb-IqG8HAu-nhIYAsgj9Vmc_b9o7vO-js,22
+memory_classification_engine/async_carrymem.py,sha256=FUhobyKXRsjIy1pDsM9rggNdnNYWcBQipK5UyYjmSag,5439
+memory_classification_engine/backup.py,sha256=Tu0sN_BmiEbq7hqryP4Iw5XoZJN-CPPv0ttKLiZrbeY,5300
+memory_classification_engine/cache.py,sha256=fA6js9xpyD5tCi0g9huCjck0rXmMJtoEjSg90fthvRE,3779
+memory_classification_engine/carrymem.py,sha256=Ezf9ekpMDJl-Ofw3Hbt147b_iXOcNihuCc3XneAdOkU,35693
+memory_classification_engine/cli.py,sha256=QbHK4O92X99l-dTYilJ_x5kSeMOWDTlSSiENRhCNjVM,45706
+memory_classification_engine/conflict_detector.py,sha256=8p1xFSPoB-FqBKZ0LNVFEHDWjsRtr1bQb0kpVDnZ1wM,14722
+memory_classification_engine/context.py,sha256=H5nPNL19KQGDm3UNyLec8FTVDZGQ1nSOn1Qu7SNBo1Q,8711
+memory_classification_engine/engine.py,sha256=hQfpdLiIm7CpkV-WlT7lTlSfj6RvBNuJjz274bxJrew,7560
+memory_classification_engine/exceptions.py,sha256=ToipK2mWFb2wx5iVaD5g0_fxyrLB7114E-hnZcKd-Dk,1036
+memory_classification_engine/merge.py,sha256=O8qpKWAVP-4jx48sUUTDsFHMpnHmuYYBiNJj5nP05sU,3831
+memory_classification_engine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+memory_classification_engine/quality_scorer.py,sha256=GaZGWMZbRVBOA7QFbCVKWhaSPHWOzy9KtWxWqm3K1gg,14155
+memory_classification_engine/scoring.py,sha256=v05_SNrwbP3EB8qpN5zA5sbBM-GL9EpTvwKJ3LI2Lxs,2152
+memory_classification_engine/tui.py,sha256=aiGZok5Z0xH9x7V-a4jmM_0c5FQoLo231UsPae74u0w,11146
+memory_classification_engine/adapters/__init__.py,sha256=X9aqTxjSdlrkrTuwQZZCRs2a-UPkozdU9cWnxs8_emg,452
+memory_classification_engine/adapters/base.py,sha256=dnyvrG9t7xpqYCnGVhNlft5b3cGjiTLaXIGdGll8VCU,17972
+memory_classification_engine/adapters/json_adapter.py,sha256=jC36CqDwormNRAS8ylDsECG6qIo_3pJcxO5fiN0-orU,8834
+memory_classification_engine/adapters/loader.py,sha256=-RIUexk0io0oKpmTc4Uj5Z9kzG0SIyRhxxm5xJ-ErJI,1964
+memory_classification_engine/adapters/obsidian_adapter.py,sha256=DQMhofpBAHEdIRwagU360-uPwbRByWoh3rgJCD7kjVw,14207
+memory_classification_engine/adapters/sqlite_adapter.py,sha256=vDbfh5lY9sd6b4ZnUH7iepjYjdYkS7mhDJCsqFudXCo,47831
+memory_classification_engine/coordinators/__init__.py,sha256=7l8s03dgvySdtvO9SrxWoQKOusJ1mVhevhWpAqpVXh8,207
+memory_classification_engine/coordinators/classification_pipeline.py,sha256=B9QXbcA92e1RHJLBhG542iBuwODLKs6r7DDKtHaeVtk,10939
+memory_classification_engine/integration/__init__.py,sha256=UxyGF5kOWDtERkKJ_Vq_1ve98jgfuNV_1bfhnznjtNc,256
+memory_classification_engine/integration/layer2_mcp/__init__.py,sha256=PnwSnzjmxMoV_THDM5oVCW14i6RKF2_jzdQ5eEp27I4,672
+memory_classification_engine/integration/layer2_mcp/__main__.py,sha256=Dd5Pz17wZhF83NMTTNI1wZQV8ft8mI_ryq7qVlHo3Rs,408
+memory_classification_engine/integration/layer2_mcp/handlers.py,sha256=0h3pt9l3NQK_eLzjj_eihG_L7C6bt9QwshaOFdzbw4k,13545
+memory_classification_engine/integration/layer2_mcp/http_server.py,sha256=p3Qy4wuCBcHHWmvF_C42JMDap6LnF46k4mmvyXhTBSg,8908
+memory_classification_engine/integration/layer2_mcp/server.py,sha256=siYIxxVj9BFeGZJtkB4xkSL3roRe9Q1Vsd7-B-0Hf4g,9186
+memory_classification_engine/integration/layer2_mcp/tools.py,sha256=6LWNrMtp3r9Y39N40lCN-QomExsb8_RMt3gWMjJpl00,20711
+memory_classification_engine/layers/__init__.py,sha256=-vGtS-60ysipJtPvZP1qcP3cnILcV8rWABkvXWzbTZY,42
+memory_classification_engine/layers/feedback_loop.py,sha256=EpHsNkmrfXHCr8spxm0AjxPGhOWnvvt8s5b7BhR2YxA,15036
+memory_classification_engine/layers/pattern_analyzer.py,sha256=HhHQRNcb8eKVlmUynjHKptKnonHDn8ThSb7ey3qGfkM,68560
+memory_classification_engine/layers/rule_matcher.py,sha256=eGvVAT3beGEqs-NMsb8QFyUj5vqmmTNdsuREXbRkn80,3595
+memory_classification_engine/layers/semantic_classifier.py,sha256=eRIT0j0CI_mlKKcA6N8IWdEaO9JakQNF4sastmH57qs,4170
+memory_classification_engine/security/__init__.py,sha256=yCn65alpfR8D3ddWANWtQW03UtezoSd4Xxl6NjmLvd8,635
+memory_classification_engine/security/audit.py,sha256=ekgUSFq5LxrkDwVWIp0J-TqoT-10rSq0FwnRpXqTHd8,5364
+memory_classification_engine/security/encryption.py,sha256=8Q--xQB2lN3-1ySvYW64J3OU4xKSHfcXRDYZ9eSm7HU,6905
+memory_classification_engine/security/input_validator.py,sha256=0W_pyHjjaNg7wStyALQ1jXbV_BAaiEa9zsNWOJh0IEg,14715
+memory_classification_engine/semantic/__init__.py,sha256=G8UX34s7QUHy7UbN0Nhlu0Su3TqS4a7iPKqfcE2YFoI,433
+memory_classification_engine/semantic/expander.py,sha256=xt4vMZ0wsJ9GDbPYe2mxu1SV_jvdL-woXTtdg4nB3yI,10810
+memory_classification_engine/semantic/merger.py,sha256=0c2__8yOCw9x_bKl8xwHhrY2X-9f9bg7PvtvX8S9djc,8616
+memory_classification_engine/semantic/data/__init__.py,sha256=F7w9c4fbjm_MVCi67b-iGa64L1OLCvIfnWrpgYf-6GI,509
+memory_classification_engine/semantic/data/synonyms_daily_en.yaml,sha256=uAJVrZg0KQl4bf5LHI8zre4Gz3rg7x-p6DboaE1bBjs,4576
+memory_classification_engine/semantic/data/synonyms_jp.yaml,sha256=vh1nCtQVXICkds-70fu2b_V0-FpddMRVI2Wuy4BMwEE,6707
+memory_classification_engine/semantic/data/synonyms_technical_cn.yaml,sha256=6V4N0z-6eXhLNQudPk3i3CyBKppUZjAulzXby19KJJ8,5515
+memory_classification_engine/utils/__init__.py,sha256=MAwLQHvhSD6usiJ-z90mBlwkk_Wc18rBwS2ZYWk5r9A,36
+memory_classification_engine/utils/config.py,sha256=iKTyF03I9EoK7N6PfI9LlM9wXtnEAjFvdClz2YN_9bI,3090
+memory_classification_engine/utils/confirmation.py,sha256=BOx1oaNMstF3fQ5Wfd-Gs30kBjOxNlS4dFYfpfhgq24,1438
+memory_classification_engine/utils/constants.py,sha256=oPPEDLa9tFi3SSP_U1s9lVRnX53cP52uRKk25esbcog,1798
+memory_classification_engine/utils/helpers.py,sha256=PPwlZURyyx617Mbj9-CfeqEj2Eek3DSGs-ZMV5qjolc,4133
+memory_classification_engine/utils/language.py,sha256=D5gUqERgSqLO9X5R1TGxKz_feMk3igthhq2HzmV9aCE,13514
+memory_classification_engine/utils/logger.py,sha256=umdSegCpJUfLprwePG35l1cbI0r6qEGEuB-bfFxqwFA,1839
+memory_classification_engine/utils/performance.py,sha256=162u2E2-8fe0aHe57kw5C7SUKE2FwKvabWAOX3luE8Q,9628
+memory_classification_engine/utils/validators.py,sha256=y5SCImL6u72SXOcJGYbUPENCqd0r9PKhzAym_9DiEvQ,7860
+carrymem-0.1.2.dist-info/METADATA,sha256=sGf2LbDCgtVZFINgTctyy-380C7c2ZqUEHKuLeeoxHs,13007
+carrymem-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+carrymem-0.1.2.dist-info/entry_points.txt,sha256=BLYcTwwxvMxeghUD3FCjU8G60KVBaFLrBOpiUQWyA_I,316
+carrymem-0.1.2.dist-info/top_level.txt,sha256=KXlWhebfpZ8WwwAKTpbLm2ksurYQ1rWoiz3caOudmZ8,29
+carrymem-0.1.2.dist-info/RECORD,,

carrymem-0.1.2.dist-info/WHEEL

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

carrymem-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[carrymem.adapters]
+json = memory_classification_engine.adapters.json_adapter:JSONAdapter
+obsidian = memory_classification_engine.adapters.obsidian_adapter:ObsidianAdapter
+sqlite = memory_classification_engine.adapters.sqlite_adapter:SQLiteAdapter
+
+[console_scripts]
+carrymem = memory_classification_engine.cli:main

carrymem-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 lulin70
+
+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.

carrymem-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+memory_classification_engine

memory_classification_engine/__init__.py

@@ -0,0 +1,78 @@
+"""CarryMem — Your Portable AI Memory Layer.
+
+CarryMem = MCE Classification Engine + SQLite Default Storage + Replaceable Adapters
+
+v0.8.0: Enhanced CLI, TUI, MCP setup, carrymem doctor, quality management
+
+Quick Start:
+    from memory_classification_engine import CarryMem
+
+    cm = CarryMem()
+    result = cm.classify_and_remember("I prefer dark mode")
+    memories = cm.recall_memories("dark mode")  # Also finds "深色模式", "ダークモード", etc.
+
+CLI:
+    carrymem add "I prefer dark mode"
+    carrymem list
+    carrymem search "theme"
+    carrymem setup-mcp --tool cursor
+    carrymem doctor
+"""
+
+from memory_classification_engine.carrymem import CarryMem, StorageNotConfiguredError, KnowledgeNotConfiguredError
+from memory_classification_engine.engine import MemoryClassificationEngine
+from memory_classification_engine.adapters.base import MemoryEntry, StorageAdapter, StoredMemory
+from memory_classification_engine.adapters.sqlite_adapter import SQLiteAdapter
+from memory_classification_engine.adapters.obsidian_adapter import ObsidianAdapter
+from memory_classification_engine.adapters.json_adapter import JSONAdapter
+
+try:
+    from memory_classification_engine.semantic.expander import SemanticExpander
+    from memory_classification_engine.semantic.merger import ResultMerger
+except ImportError:
+    SemanticExpander = None
+    ResultMerger = None
+
+# v0.5.0 security module
+try:
+    from memory_classification_engine.security import (
+        InputValidator,
+        ValidationError,
+        validate_content,
+        validate_query,
+        validate_namespace,
+    )
+except ImportError:
+    InputValidator = None
+    ValidationError = None
+    validate_content = None
+    validate_query = None
+    validate_namespace = None
+
+try:
+    from memory_classification_engine.async_carrymem import AsyncCarryMem
+except ImportError:
+    AsyncCarryMem = None
+
+from memory_classification_engine.__version__ import __version__
+
+__all__ = [
+    "CarryMem",
+    "MemoryClassificationEngine",
+    "MemoryEntry",
+    "StorageAdapter",
+    "StoredMemory",
+    "SQLiteAdapter",
+    "ObsidianAdapter",
+    "JSONAdapter",
+    "StorageNotConfiguredError",
+    "KnowledgeNotConfiguredError",
+    "SemanticExpander",
+    "ResultMerger",
+    "InputValidator",
+    "ValidationError",
+    "validate_content",
+    "validate_query",
+    "validate_namespace",
+    "AsyncCarryMem",
+]