claude_memory 0.1.0 → 0.2.0

data/docs/SOCIAL_MEDIA_v0.2.0.md

@@ -0,0 +1,420 @@
+# Social Media Snippets for ClaudeMemory v0.2.0
+
+## Twitter/X (280 characters)
+
+### Option 1: Feature Focus
+```
+🚀 ClaudeMemory v0.2.0 is out!
+
+✅ Privacy tags for sensitive data
+✅ 10x faster queries (progressive disclosure)
+✅ Semantic shortcuts (decisions, conventions)
+✅ 157 new tests (583 total)
+
+Give Claude Code long-term memory—automatic, intelligent, zero-config.
+
+gem install claude_memory
+
+https://github.com/codenamev/claude_memory
+```
+
+### Option 2: Privacy Focus
+```
+🔒 ClaudeMemory v0.2.0: Privacy-first memory for Claude Code
+
+Use <private>tags</private> to exclude sensitive data from memory.
+Your API keys stay private, but Claude still remembers context.
+
+10x query performance + semantic shortcuts included!
+
+gem install claude_memory
+
+https://github.com/codenamev/claude_memory
+```
+
+### Option 3: Performance Focus
+```
+⚡ ClaudeMemory v0.2.0: 10x faster memory queries!
+
+New progressive disclosure:
+• recall_index: Quick previews (~50 tokens)
+• recall_details: Full context on demand
+
+Plus: Privacy tags, semantic shortcuts, 157 new tests
+
+gem install claude_memory
+
+https://github.com/codenamev/claude_memory
+```
+
+---
+
+## LinkedIn (Professional, 2-3 paragraphs)
+
+### Version 1: Professional Announcement
+
+```
+I'm excited to announce ClaudeMemory v0.2.0, a major update to the long-term memory system for Claude Code that brings privacy-first design and significant performance improvements.
+
+ClaudeMemory enables Claude Code to maintain persistent memory across conversations—automatically extracting facts about your tech stack, architectural decisions, and coding preferences. Version 0.2.0 introduces three major capabilities:
+
+🔒 Privacy Tag System: Use <private> tags to exclude sensitive data like API keys and credentials from memory. Content is sanitized at ingestion with ReDoS protection and 100% test coverage for security-critical code.
+
+⚡ 10x Query Performance: New progressive disclosure pattern reduces token usage from 2,500 to 250 tokens by showing lightweight previews first, then full details on demand. This makes memory queries practical for production use.
+
+🎯 Semantic Shortcuts: Pre-configured queries (memory.decisions, memory.conventions, memory.architecture) eliminate manual search construction and provide instant access to common information.
+
+Built with Ruby 3.2+, backed by SQLite, with 583 test examples and zero external dependencies. Ready to use today:
+
+gem install claude_memory
+claude-memory init --global
+
+Full release notes: https://github.com/codenamev/claude_memory/releases/tag/v0.2.0
+
+#Ruby #AI #ClaudeAI #DeveloperTools #OpenSource
+```
+
+### Version 2: Technical Deep Dive
+
+```
+ClaudeMemory v0.2.0 is now available with significant architectural improvements for privacy, performance, and developer experience.
+
+Key Technical Achievements:
+
+**Privacy & Security**
+Implemented ContentSanitizer module with support for <private>, <no-memory>, and <secret> tags. Content is sanitized at ingestion with protection against ReDoS attacks (100-tag limit). Security-critical modules have 100% test coverage.
+
+**Query Optimization**
+Reduced N+1 queries from 2N+1 to 3 through batch loading of facts, provenance, and entities. New progressive disclosure pattern (recall_index + recall_details) achieves 10x token reduction while maintaining full context availability.
+
+**Domain Design**
+Introduced semantic shortcuts (decisions, conventions, architecture) using predicate-based query builder. Value objects (PrivacyTag, QueryOptions) and exit code strategy (SUCCESS/WARNING/ERROR) improve type safety and integration robustness.
+
+**Testing & Quality**
+Added 157 test examples (583 total). Achieved 100% coverage for TokenEstimator and ContentSanitizer modules. Comprehensive hook integration tests with all event types.
+
+Built as a Ruby gem with SQLite storage, MCP tools, and Claude Code hooks for seamless integration. No external dependencies or API keys required.
+
+Installation: gem install claude_memory
+
+GitHub: https://github.com/codenamev/claude_memory
+
+#Ruby #SoftwareEngineering #AI #ClaudeAI #Architecture
+```
+
+---
+
+## Mastodon / Fediverse
+
+### Version 1: Technical Community
+
+```
+📢 ClaudeMemory v0.2.0 released!
+
+Long-term memory for Claude Code with privacy, performance, and polish.
+
+🔒 Privacy tags: <private>secret</private> never gets stored
+⚡ 10x token reduction with progressive disclosure
+🎯 Semantic shortcuts for decisions, conventions, architecture
+✅ 583 test examples (157 new)
+
+Built with Ruby 3.2+ and SQLite. Zero external dependencies.
+
+gem install claude_memory
+
+Full details: https://github.com/codenamev/claude_memory
+
+#Ruby #ClaudeCode #OpenSource #DeveloperTools #AI
+```
+
+### Version 2: Ruby Community Focus
+
+```
+🚀 New Ruby gem alert: ClaudeMemory v0.2.0
+
+Give Claude Code persistent memory across all conversations. Built with:
+• Ruby 3.2+
+• Sequel ORM
+• SQLite3 storage
+• Standard Ruby linting
+• RSpec (583 examples)
+
+New in v0.2.0:
+• Privacy tag system
+• Progressive disclosure (10x faster)
+• Semantic shortcuts
+• Exit code strategy for hooks
+• 100% test coverage for critical modules
+
+Clean architecture with Domain-Driven Design, value objects, and SOLID principles.
+
+Installation: gem install claude_memory
+
+https://github.com/codenamev/claude_memory
+
+#Ruby #RubyGems #ClaudeCode #SQLite #OpenSource
+```
+
+---
+
+## Hacker News (Title + Comment)
+
+### Title Option 1
+```
+ClaudeMemory v0.2.0 – Privacy-first long-term memory for Claude Code
+```
+
+### Title Option 2
+```
+Show HN: ClaudeMemory v0.2.0 with privacy tags and 10x query performance
+```
+
+### Comment (First Comment in Thread)
+
+```
+Hi HN! Author here.
+
+I'm releasing ClaudeMemory v0.2.0, a Ruby gem that gives Claude Code persistent memory across conversations. It extracts facts about your tech stack, decisions, and preferences automatically—no API keys or configuration needed.
+
+This release focuses on three areas:
+
+1. Privacy: New <private> tag system strips sensitive data at ingestion. Your API keys never get stored, but Claude still remembers the context around them.
+
+2. Performance: Progressive disclosure pattern reduces token usage by 10x. Quick previews first (recall_index), full details on demand (recall_details).
+
+3. Developer Experience: Semantic shortcuts (memory.decisions, memory.conventions) eliminate manual query construction. Exit code strategy for robust hook integration.
+
+Architecture highlights:
+• Ruby 3.2+ with Sequel ORM and SQLite3
+• Domain-Driven Design with rich models
+• 583 test examples (157 new in this release)
+• Zero external dependencies
+• No embedding models or vector databases (uses SQLite FTS5)
+
+The system uses Claude Code's hooks and MCP tools for seamless integration. Facts are extracted using Claude's own intelligence during session stop hooks—no separate LLM API needed.
+
+GitHub: https://github.com/codenamev/claude_memory
+
+Happy to answer questions!
+```
+
+---
+
+## Reddit r/ruby
+
+### Title
+```
+[Release] ClaudeMemory v0.2.0 - Long-term memory for Claude Code with privacy and performance
+```
+
+### Post Body
+
+```
+Hi r/ruby! I'm excited to share ClaudeMemory v0.2.0, a Ruby gem that provides persistent memory for Claude Code.
+
+## What It Does
+
+ClaudeMemory gives Claude Code the ability to remember facts across conversations—your tech stack, architectural decisions, coding preferences, etc. It extracts knowledge automatically and makes it available in future sessions.
+
+## What's New in v0.2.0
+
+**Privacy Tag System**
+```ruby
+# Content like this:
+"API key is <private>sk-abc123</private>"
+
+# Gets sanitized to:
+"API key is "
+
+# The key is never stored or indexed
+```
+
+**Progressive Disclosure (10x Performance)**
+```ruby
+# Phase 1: Lightweight previews
+memory.recall_index(query: "database")
+# Returns ~50 tokens per fact
+
+# Phase 2: Full details on demand
+memory.recall_details(fact_id: 42)
+# Returns complete provenance
+```
+
+**Semantic Shortcuts**
+```ruby
+memory.decisions      # Quick decision lookup
+memory.conventions    # Coding standards
+memory.architecture   # Framework choices
+```
+
+## Technical Details
+
+- **Language:** Ruby 3.2+
+- **Storage:** SQLite3 with FTS5 for full-text search
+- **ORM:** Sequel
+- **Testing:** RSpec with 583 examples
+- **Linting:** Standard Ruby
+- **Architecture:** Domain-Driven Design with value objects
+
+No external dependencies. No API keys. No embedding models. Just SQLite and Ruby.
+
+## Installation
+
+```bash
+gem install claude_memory
+claude-memory init --global
+claude-memory doctor
+```
+
+## Links
+
+- **GitHub:** https://github.com/codenamev/claude_memory
+- **RubyGems:** https://rubygems.org/gems/claude_memory
+- **Examples:** https://github.com/codenamev/claude_memory/blob/main/docs/EXAMPLES.md
+- **Changelog:** https://github.com/codenamev/claude_memory/blob/main/CHANGELOG.md
+
+Happy to answer questions or hear feedback!
+```
+
+---
+
+## Ruby Weekly Submission
+
+### Email Subject
+```
+[Submission] ClaudeMemory v0.2.0 - Long-term memory for Claude Code
+```
+
+### Email Body
+
+```
+Hi Ruby Weekly team,
+
+I'd like to submit ClaudeMemory v0.2.0 for consideration in an upcoming edition.
+
+**Title:** ClaudeMemory v0.2.0 – Privacy-first long-term memory for Claude Code
+
+**Description:**
+A Ruby gem that gives Claude Code persistent memory across conversations. Version 0.2.0 introduces privacy tags for sensitive data, progressive disclosure (10x token reduction), and semantic shortcuts. Built with Ruby 3.2+, Sequel, and SQLite. 583 test examples, zero external dependencies.
+
+**Link:** https://github.com/codenamev/claude_memory
+
+**Release Notes:** https://github.com/codenamev/claude_memory/blob/main/docs/RELEASE_NOTES_v0.2.0.md
+
+Thanks for your consideration!
+
+Valentino Stoll
+https://github.com/codenamev
+```
+
+---
+
+## Bluesky
+
+### Version 1: Feature Highlights
+
+```
+🚀 ClaudeMemory v0.2.0 is here!
+
+Long-term memory for Claude Code with:
+🔒 Privacy tags: <private>secrets</private> never stored
+⚡ 10x faster queries (progressive disclosure)
+🎯 Semantic shortcuts (decisions, conventions)
+✅ 583 tests, zero dependencies
+
+Built with Ruby + SQLite. Zero config.
+
+gem install claude_memory
+
+github.com/codenamev/claude_memory
+```
+
+### Version 2: Ruby Community
+
+```
+New Ruby gem: ClaudeMemory v0.2.0
+
+Give Claude Code persistent memory. Built with Ruby 3.2+, Sequel, and SQLite.
+
+Major features:
+• Privacy tag system for sensitive data
+• Progressive disclosure (10x token savings)
+• Semantic shortcuts for common queries
+• 583 RSpec examples
+• Domain-Driven Design architecture
+
+gem install claude_memory
+
+github.com/codenamev/claude_memory
+```
+
+---
+
+## Dev.to Article (Optional Extended Format)
+
+### Title
+```
+ClaudeMemory v0.2.0: Building a Privacy-First Memory System for AI Agents
+```
+
+### Tags
+```
+ruby, ai, claude, sqlite, opensource
+```
+
+### Article Outline
+```markdown
+# Introduction
+- What is ClaudeMemory
+- Why persistent memory matters for AI coding assistants
+
+# The Privacy Challenge
+- Why API keys and secrets are dangerous in memory systems
+- The privacy tag solution
+- Implementation details (ContentSanitizer)
+
+# Token Economics
+- The cost of context in LLM queries
+- Progressive disclosure pattern
+- 10x performance improvement analysis
+
+# Architecture Decisions
+- Why SQLite instead of vector databases
+- Domain-Driven Design in Ruby
+- Value objects and null objects
+
+# Lessons Learned
+- Testing security-critical code (100% coverage)
+- ReDoS protection
+- Hook integration patterns
+
+# Try It Yourself
+- Installation instructions
+- Example usage
+- Links to documentation
+
+# Conclusion
+- What's next for ClaudeMemory
+- Call for feedback and contributions
+```
+
+---
+
+## Usage Notes
+
+1. **Twitter/X**: Use Option 1 for broad audience, Option 2 for privacy focus, Option 3 for performance focus
+2. **LinkedIn**: Use Version 1 for general professional audience, Version 2 for technical deep dive
+3. **Mastodon**: Use Version 1 for general tech community, Version 2 for Ruby-specific communities
+4. **Hacker News**: Choose title based on current HN trends (privacy vs. performance vs. Show HN)
+5. **Reddit**: Post to r/ruby first, then cross-post to r/programming if it gets traction
+6. **Ruby Weekly**: Send submission email after GitHub release is live
+7. **Bluesky**: Similar to Twitter but can be slightly more technical
+8. **Dev.to**: Consider writing full article after initial announcement settles
+
+## Recommended Posting Schedule
+
+1. **Day 1 (Release Day)**: GitHub Release, Twitter/X, Mastodon, Bluesky
+2. **Day 2**: LinkedIn (professional announcement), Reddit r/ruby
+3. **Day 3**: Hacker News (mid-week for best visibility)
+4. **Week 1**: Ruby Weekly submission, Dev.to article (if time permits)
+5. **Week 2**: Follow up with lessons learned posts based on feedback