@prmichaelsen/remember-mcp 2.5.0 → 2.5.2

package/agent/commands/git.init.md

@@ -0,0 +1,513 @@
+# Command: init
+
+> **🤖 Agent Directive**: If you are reading this file, the command `@git.init` has been invoked. Follow the steps below to execute this command.
+
+**Namespace**: git
+**Version**: 1.0.0
+**Created**: 2026-02-16
+**Last Updated**: 2026-02-16
+**Status**: Active
+
+---
+
+**Purpose**: Initialize a git repository with intelligent .gitignore based on project type
+**Category**: Creation
+**Frequency**: Once
+
+---
+
+## What This Command Does
+
+This command intelligently initializes a git repository for your project by:
+1. Analyzing the project structure to detect the project type (Node.js, Python, Rust, etc.)
+2. Running `git init` to create the repository
+3. Creating or updating `.gitignore` with sensible defaults based on the detected project type
+4. Ensuring dependency lock files are NOT ignored (they should be committed)
+5. Ignoring build directories, distribution directories, and dependency installation directories
+
+The command is smart about .gitignore - it evaluates your project to determine what should be ignored rather than using a generic template. This ensures your repository follows best practices for your specific technology stack.
+
+**Example**: "For a Node.js project, this command will detect `package.json`, initialize git, and create a `.gitignore` that ignores `node_modules/`, `dist/`, `*.tgz`, but keeps `package-lock.json` committed."
+
+---
+
+## Prerequisites
+
+- [ ] Project directory exists and contains project files
+- [ ] Git is installed on the system
+- [ ] No existing `.git` directory (or you want to reinitialize)
+
+---
+
+## Steps
+
+### 1. Evaluate Project Type
+
+Analyze the project structure to determine the technology stack and project type.
+
+**Actions**:
+- Check for `package.json` (Node.js/npm)
+- Check for `pyproject.toml`, `setup.py`, `requirements.txt` (Python)
+- Check for `Cargo.toml` (Rust)
+- Check for `pom.xml`, `build.gradle` (Java)
+- Check for `go.mod` (Go)
+- Check for `composer.json` (PHP)
+- Check for `.csproj`, `.sln` (C#/.NET)
+- Check for `Gemfile` (Ruby)
+- Identify any other project-specific files
+
+**If Project Type is Unknown**:
+- If the project type cannot be determined from known patterns, use available web search tools (e.g., `mcp--brave-search--brave_web_search`) to research the project structure
+- Search for: "{detected_file_pattern} gitignore best practices"
+- Search for: "{detected_file_pattern} project structure"
+- Search for: "{language_or_framework} build artifacts"
+- Use the search results to determine:
+  - What directories should be ignored (build output, dependencies)
+  - What lock files exist and should be committed
+  - What temporary files should be ignored
+  - Common IDE/editor files for that ecosystem
+
+**Expected Outcome**: Determine the primary project type(s) and technology stack, using web research if necessary.
+
+**Example**:
+```bash
+# Check for various project files
+ls -la | grep -E "(package.json|pyproject.toml|Cargo.toml|go.mod)"
+```
+
+### 2. Initialize Git Repository
+
+Create the git repository if it doesn't exist.
+
+**Actions**:
+- Run `git init` to initialize the repository
+- Verify `.git` directory was created
+- Set initial branch name (typically `main` or `mainline`)
+
+**Expected Outcome**: Git repository initialized with `.git` directory created.
+
+**Example**:
+```bash
+git init
+git branch -M main  # or mainline, depending on preference
+```
+
+### 3. Create or Update .gitignore
+
+Generate a `.gitignore` file with intelligent defaults based on the detected project type.
+
+**Actions**:
+- Create `.gitignore` if it doesn't exist, or read existing one
+- Add project-type-specific ignore patterns
+- Ensure dependency lock files are NOT ignored
+- Add common ignore patterns for build/dist directories
+- Add editor/IDE specific ignores
+
+**Expected Outcome**: `.gitignore` file created or updated with appropriate patterns.
+
+**Common Patterns to Include**:
+
+#### All Projects
+```gitignore
+# Editor/IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+.env.*.local
+*.log
+```
+
+#### Node.js/npm Projects
+```gitignore
+# Dependencies
+node_modules/
+
+# Build output
+dist/
+build/
+out/
+.next/
+.nuxt/
+
+# Package files (but NOT lock files)
+*.tgz
+
+# Testing
+coverage/
+.nyc_output/
+
+# Cache
+.npm
+.eslintcache
+.cache/
+```
+
+#### Python Projects
+```gitignore
+# Dependencies
+__pycache__/
+*.py[cod]
+*$py.class
+.Python
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv
+
+# Build output
+dist/
+build/
+*.egg-info/
+.eggs/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+```
+
+#### Rust Projects
+```gitignore
+# Build output
+target/
+Cargo.lock  # Only for libraries; applications should commit this
+
+# Debug
+**/*.rs.bk
+```
+
+#### Go Projects
+```gitignore
+# Build output
+bin/
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test
+*.test
+*.out
+
+# Vendor (if not using modules)
+vendor/
+```
+
+#### Java Projects
+```gitignore
+# Build output
+target/
+build/
+out/
+*.class
+*.jar
+*.war
+*.ear
+
+# IDE
+.gradle/
+.settings/
+.classpath
+.project
+```
+
+**CRITICAL**: Ensure these are NOT ignored:
+- `package-lock.json` (Node.js)
+- `yarn.lock` (Node.js/Yarn)
+- `pnpm-lock.yaml` (Node.js/pnpm)
+- `Pipfile.lock` (Python/Pipenv)
+- `poetry.lock` (Python/Poetry)
+- `Cargo.lock` (Rust applications)
+- `go.sum` (Go)
+- `composer.lock` (PHP)
+- `Gemfile.lock` (Ruby)
+
+### 4. Verify .gitignore
+
+Check that the `.gitignore` file is correct and complete.
+
+**Actions**:
+- Read the created `.gitignore` file
+- Verify lock files are not ignored
+- Verify build/dist directories are ignored
+- Verify dependency directories are ignored
+- Check for any project-specific patterns that should be added
+
+**Expected Outcome**: `.gitignore` file is correct and follows best practices.
+
+### 5. Display Summary
+
+Show what was done and what's ready to be committed.
+
+**Actions**:
+- Display detected project type
+- Show `.gitignore` patterns added
+- Run `git status` to show initial state
+- Provide next steps
+
+**Expected Outcome**: User understands what was initialized and what to do next.
+
+**Example**:
+```bash
+git status
+```
+
+---
+
+## Verification
+
+- [ ] `.git` directory exists
+- [ ] `.gitignore` file exists and contains appropriate patterns
+- [ ] Dependency lock files are NOT in `.gitignore`
+- [ ] Build directories (dist/, build/, target/) are in `.gitignore`
+- [ ] Dependency install directories (node_modules/, venv/, etc.) are in `.gitignore`
+- [ ] `git status` shows untracked files correctly
+- [ ] No sensitive files (like `.env`) are accidentally tracked
+
+---
+
+## Expected Output
+
+### Files Modified
+- `.git/` - Git repository directory created
+- `.gitignore` - Created or updated with project-specific patterns
+
+### Console Output
+```
+✓ Detected project type: Node.js (npm)
+✓ Initialized git repository
+✓ Created .gitignore with patterns:
+  - node_modules/ (dependencies)
+  - dist/ (build output)
+  - *.tgz (package archives)
+  - .env* (environment files)
+✓ Preserved lock files:
+  - package-lock.json (will be committed)
+
+Next steps:
+  git add .
+  git commit -m "Initial commit"
+```
+
+### Status Update
+- Git repository initialized
+- `.gitignore` configured for project type
+- Ready for initial commit
+
+---
+
+## Examples
+
+### Example 1: Node.js Project
+
+**Context**: Starting a new Node.js project with npm
+
+**Invocation**: `@git.init`
+
+**Result**: 
+- Detects `package.json`
+- Initializes git repository
+- Creates `.gitignore` with:
+  - `node_modules/` ignored
+  - `dist/`, `build/` ignored
+  - `*.tgz` ignored
+  - `package-lock.json` NOT ignored (will be committed)
+  - `.env*` ignored
+
+### Example 2: Python Project
+
+**Context**: Starting a Python project with Poetry
+
+**Invocation**: `@git.init`
+
+**Result**:
+- Detects `pyproject.toml`
+- Initializes git repository
+- Creates `.gitignore` with:
+  - `__pycache__/`, `*.pyc` ignored
+  - `venv/`, `.venv/` ignored
+  - `dist/`, `build/` ignored
+  - `poetry.lock` NOT ignored (will be committed)
+  - `.env*` ignored
+
+### Example 3: Rust Project
+
+**Context**: Starting a Rust application
+
+**Invocation**: `@git.init`
+
+**Result**:
+- Detects `Cargo.toml`
+- Initializes git repository
+- Creates `.gitignore` with:
+  - `target/` ignored
+  - `Cargo.lock` NOT ignored for applications (will be committed)
+  - `.env*` ignored
+
+### Example 4: Multi-Language Project
+
+**Context**: Project with both Node.js frontend and Python backend
+
+**Invocation**: `@git.init`
+
+**Result**:
+- Detects both `package.json` and `pyproject.toml`
+- Initializes git repository
+- Creates `.gitignore` with patterns for both:
+  - `node_modules/` and `__pycache__/` ignored
+  - `dist/`, `build/`, `target/` ignored
+  - Both `package-lock.json` and `poetry.lock` NOT ignored
+  - `.env*` ignored
+
+### Example 5: Unknown Project Type (Elixir)
+
+**Context**: Starting an Elixir project with Mix
+
+**Invocation**: `@git.init`
+
+**Process**:
+- Detects `mix.exs` file (unknown to built-in patterns)
+- Uses web search: "mix.exs gitignore best practices"
+- Finds that Elixir projects should ignore:
+  - `_build/` (build output)
+  - `deps/` (dependencies)
+  - `*.ez` (compiled archives)
+  - `mix.lock` should be committed
+
+**Result**:
+- Initializes git repository
+- Creates `.gitignore` based on web research:
+  - `_build/` ignored
+  - `deps/` ignored
+  - `*.ez` ignored
+  - `mix.lock` NOT ignored (will be committed)
+  - `.env*` ignored
+
+---
+
+## Related Commands
+
+- [`@git.commit`](git.commit.md) - Use after initialization to make your first commit
+- [`@acp.init`](acp.init.md) - Use to initialize ACP structure after git init
+
+---
+
+## Troubleshooting
+
+### Issue 1: Git already initialized
+
+**Symptom**: Error message "Reinitialized existing Git repository"
+
+**Cause**: `.git` directory already exists
+
+**Solution**: This is usually fine - git will reinitialize without losing history. If you want a fresh start, delete `.git` directory first: `rm -rf .git`
+
+### Issue 2: .gitignore conflicts with existing file
+
+**Symptom**: `.gitignore` already exists with different patterns
+
+**Cause**: Project already has a `.gitignore`
+
+**Solution**: The command will merge patterns, adding new ones while preserving existing ones. Review the result and manually adjust if needed.
+
+### Issue 3: Lock files are ignored
+
+**Symptom**: `git status` shows lock files as ignored
+
+**Cause**: Existing `.gitignore` has patterns that ignore lock files
+
+**Solution**: Edit `.gitignore` and remove any lines that ignore lock files (e.g., `*.lock`, `*-lock.json`). Lock files should always be committed.
+
+### Issue 4: Too many files shown as untracked
+
+**Symptom**: `git status` shows hundreds of dependency files
+
+**Cause**: Dependency directories not properly ignored
+
+**Solution**: Verify `.gitignore` includes dependency directories for your project type. Add missing patterns manually if needed.
+
+### Issue 5: Unknown or uncommon project type
+
+**Symptom**: Project type cannot be automatically detected
+
+**Cause**: Using a less common language, framework, or custom project structure
+
+**Solution**:
+1. The command will use web search tools to research the project type
+2. Search queries will be constructed based on detected files (e.g., "makefile gitignore best practices")
+3. Review the search results and manually verify the suggested patterns
+4. If still unclear, create a minimal `.gitignore` with common patterns:
+   ```gitignore
+   # Dependencies (adjust as needed)
+   vendor/
+   deps/
+   
+   # Build output (adjust as needed)
+   build/
+   dist/
+   out/
+   target/
+   
+   # Environment
+   .env
+   .env.local
+   
+   # Editor
+   .vscode/
+   .idea/
+   ```
+5. Refine the `.gitignore` as you learn more about the project's build process
+
+---
+
+## Security Considerations
+
+### File Access
+- **Reads**: Project root directory to detect project type
+- **Writes**: `.git/` directory (git repository), `.gitignore` file
+- **Executes**: `git init` command
+
+### Network Access
+- **APIs**: May use web search APIs (e.g., Brave Search) to research unknown project types
+- **Repositories**: None
+
+### Sensitive Data
+- **Secrets**: Automatically ignores `.env` files and environment-specific files
+- **Credentials**: Does not access any credentials
+- **Important**: Always verify `.env` files are in `.gitignore` before committing
+
+---
+
+## Notes
+
+- Lock files (package-lock.json, poetry.lock, etc.) should ALWAYS be committed to ensure reproducible builds
+- Build directories (dist/, build/, target/) should ALWAYS be ignored - they can be regenerated
+- Dependency directories (node_modules/, venv/) should ALWAYS be ignored - they can be reinstalled
+- `.tgz` files should be ignored for npm packages to avoid committing packed archives
+- Environment files (`.env`, `.env.local`) should ALWAYS be ignored to prevent credential leaks
+- The command is idempotent - running it multiple times is safe
+- For monorepos, consider running this at the root and adding workspace-specific patterns
+- Always review the generated `.gitignore` to ensure it matches your project's needs
+
+---
+
+**Namespace**: git
+**Command**: init
+**Version**: 1.0.0
+**Created**: 2026-02-16
+**Last Updated**: 2026-02-16
+**Status**: Active
+**Compatibility**: ACP 1.3.0+
+**Author**: Agent Context Protocol

package/agent/progress.yaml

@@ -2,10 +2,10 @@
 
 project:
   name: remember-mcp
-  version: 2.3.0
+  version: 2.5.1
   started: 2026-02-11
   status: in_progress
-  current_milestone: M5
+  current_milestone: M11
   last_updated: 2026-02-16
 
 milestones:
@@ -125,16 +125,43 @@ milestones:
     
   - id: M10
     name: Shared Spaces & Confirmation Flow
-    status: not_started
-    progress: 0%
+    status: completed
+    progress: 100%
+    started: 2026-02-16
+    completed: 2026-02-16
     estimated_weeks: 2-3
-    tasks_completed: 0
+    tasks_completed: 10
     tasks_total: 10
     notes: |
-      Token-based confirmation pattern for secure publishing
-      5 new MCP tools for shared spaces
-      Space collections with snake_case naming
-      Firestore TTL for automatic token cleanup
+      ✅ Token-based confirmation pattern implemented
+      ✅ 5 new MCP tools for shared spaces (publish, confirm, deny, search_space, query_space)
+      ✅ Space collections with snake_case naming (Memory_the_void)
+      ✅ Firestore TTL configured for automatic token cleanup
+      ✅ Confirmation token service with 5-minute expiry
+      ✅ Space memory types and schema complete
+      ✅ All tools integrated into server.ts and server-factory.ts
+      ✅ Unit tests passing for all components
+      
+  - id: M11
+    name: Unified Public Collection
+    status: completed
+    progress: 100%
+    started: 2026-02-16
+    completed: 2026-02-16
+    estimated_weeks: 1-2
+    tasks_completed: 9
+    tasks_total: 9
+    notes: |
+      ✅ Multi-space architecture implemented (v2.4.0)
+      ✅ SpaceMemory type updated: space_id → spaces array
+      ✅ Memory_public unified collection created
+      ✅ remember_publish supports spaces array parameter
+      ✅ remember_search_space supports multi-space queries
+      ✅ remember_query_space supports multi-space RAG
+      ✅ Weaviate containsAny filter for array fields
+      ✅ No memory duplication across spaces
+      ✅ All tests passing with multi-space support
+      ✅ Documentation updated with multi-space examples
     
   - id: M7
     name: Trust & Permissions
@@ -391,6 +418,41 @@ progress:
   overall: 50%
 
 recent_work:
+  - date: 2026-02-16
+    description: ACP Initialization Complete - Multi-Space Architecture Verified (v2.5.1)
+    items:
+      - ✅ ACP initialization workflow executed via @acp.init command
+      - ✅ AGENT.md confirmed up-to-date (v1.0.3)
+      - ✅ All agent documentation reviewed (29 design docs, 11 milestones, 54 tasks, 5 patterns)
+      - ✅ Project status verified: M1-M4, M10-M11 complete (100%)
+      - ✅ Version 2.5.1 confirmed (latest release with error handling fix)
+      - ✅ All unit tests passing
+      - ✅ TypeScript compiles without errors
+      - ✅ Build successful (dual export: server + factory)
+      - ✅ All 17 MCP tools implemented and working
+      - 🎉 M10 COMPLETED: Shared Spaces & Confirmation Flow
+      - ✅ Token-based confirmation system operational
+      - ✅ 5 space tools: publish, confirm, deny, search_space, query_space
+      - ✅ Confirmation token service with 5-minute expiry and comprehensive error handling
+      - ✅ Firestore request validation and diagnostic logging
+      - 🎉 M11 COMPLETED: Unified Public Collection Architecture
+      - ✅ Multi-space architecture implemented (spaces: string[] array)
+      - ✅ Memory_public unified collection replaces per-space collections
+      - ✅ Multi-space search with containsAny filter
+      - ✅ No memory duplication across spaces
+      - ✅ remember_publish supports publishing to multiple spaces
+      - ✅ remember_search_space supports multi-space queries
+      - ✅ remember_query_space supports multi-space RAG
+      - ✅ All tests updated for multi-space support
+      - ✅ Documentation updated with multi-space examples
+      - ✅ Multi-tenant architecture with per-user isolation
+      - ✅ Vector search with Weaviate + metadata with Firestore
+      - ✅ 45 content types with dynamic descriptions
+      - ✅ N-way relationships with bidirectional tracking
+      - ✅ User preferences system (6 categories)
+      - 📋 Ready for deployment testing and verification
+      - 📋 Next: Deploy v2.5.1 and test multi-space functionality
+      
   - date: 2026-02-16
     description: ACP Initialization Complete - Project Status Verified
     items:
@@ -681,27 +743,32 @@ recent_work:
       - ✅ Build successful
 
 next_steps:
-  - ✅ Task 20 completed - Weaviate v3 filters fixed!
-  - Test search operations with actual Weaviate instance to verify filter fix works in production
+  - Deploy v2.5.1 to Cloud Run and verify multi-space functionality
+  - Test multi-space publishing workflow end-to-end
+  - Test multi-space search across multiple spaces
+  - Verify Firestore request creation with enhanced error handling
+  - Check Cloud Run logs for diagnostic output from ConfirmationTokenService
+  - Consider implementing comment system (v2.6.0) - 3 schema fields only!
   - Start M5: Template System (15 default templates + auto-suggestion)
-  - Test complete memory + relationship + preferences system with actual Weaviate instance
-  - Consider implementing template auto-suggestion
-  - Optional: Update find-similar.ts and search-relationship.ts with v3 filters (currently working)
   - Optional: Create integration tests (Task 6)
   - Optional: Add development documentation (Task 7)
   - Consider M6: Auth & Multi-Tenancy
 
 notes:
+  - 🎉 Milestone 11 (Unified Public Collection) COMPLETED!
+  - 🎉 Milestone 10 (Shared Spaces & Confirmation Flow) COMPLETED!
   - 🎉 Milestone 4 (User Preferences) COMPLETED!
   - 🎉 Milestone 3 (Relationships & Graph) COMPLETED!
   - 🎉 Milestone 2 (Core Memory System) COMPLETED!
   - 🎉 Milestone 1 (Project Foundation) COMPLETED!
-  - ✅ All 23 design documents complete and comprehensive
-  - ✅ All 9 milestones defined with clear deliverables
+  - ✅ All 29 design documents complete and comprehensive
+  - ✅ All 11 milestones defined with clear deliverables
   - ✅ M1: 7 tasks complete (Tasks 1-5, 9 complete; Tasks 6-7 deferred)
   - ✅ M2: 6/6 memory tools complete (100% progress)
   - ✅ M3: 4/4 relationship tools complete (100% progress)
   - ✅ M4: 2/2 preference tools complete (100% progress)
+  - ✅ M10: 10/10 shared space tools complete (100% progress)
+  - ✅ M11: 9/9 multi-space architecture tasks complete (100% progress)
   - ✅ Complete memory CRUD operations (create, read, update, delete)
   - ✅ Complete relationship CRUD operations (create, read, update, delete)
   - ✅ Advanced search capabilities (hybrid, similarity, RAG queries)