@rembr/vscode 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,91 @@
+# Changelog
+
+All notable changes to @rembr/client will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-01-06
+
+### Added
+
+- Initial release of @rembr/client
+- Automatic MCP server configuration for:
+  - VS Code + GitHub Copilot (`.vscode/mcp.json`)
+  - Cursor (`.cursor/mcp.json`)
+  - Windsurf (`.windsurf/mcp.json`)
+  - Claude Desktop (`~/Library/Application Support/Claude/claude_desktop_config.json`)
+- Recursive Analyst agent template for GitHub Copilot (`.github/agents/recursive-analyst.agent.md`)
+- Cursor integration rules (`.cursorrules`)
+- Windsurf cascade instructions (`.windsurfrules`)
+- Aider configuration (`.aider.conf.yml`)
+- CLI tool: `npx rembr setup`
+- Postinstall setup (optional, can be disabled with `SKIP_REMBR_SETUP=1`)
+
+### REMBR Server Features (v1.0.0)
+
+**Core Memory Tools (5)**:
+- `store_memory` - Store new memories with categories and metadata
+- `search_memory` - Hybrid, semantic, text, or phrase search with metadata filtering
+- `update_memory` - Update existing memories (auto-regenerates embeddings)
+- `delete_memory` - Remove memories
+- `list_memories` - List recent memories by category
+- `get_memory` - Retrieve specific memory by ID
+
+**Discovery Tools (2)**:
+- `find_similar_memories` - Discover related memories via semantic similarity
+- `get_embedding_stats` - Monitor embedding coverage and semantic search status
+
+**Statistics (1)**:
+- `get_stats` - Usage statistics, plan limits, memory counts
+
+**Context Management for RLMs (3)**:
+- `create_context` - Create logical groupings for related memories
+- `list_contexts` - List all contexts in project
+- `search_context` - Scoped search within a specific context
+- `add_memory_to_context` - Link memories to contexts
+
+**Snapshots for Sub-Agent Handoff (3)**:
+- `create_snapshot` - Immutable memory snapshots with TTL
+- `get_snapshot` - Retrieve snapshot with memories
+- `list_snapshots` - List available snapshots
+
+**Compilation & Analysis (3)**:
+- `get_memory_graph` - Relationship graph for context memories
+- `detect_contradictions` - Find contradicting memories
+- `get_context_insights` - Pre-compiled insights (categories, temporal patterns, entities)
+
+### Search Capabilities
+
+**4 Search Modes**:
+1. **hybrid** (default) - 0.7 semantic + 0.3 text (best for general use)
+2. **semantic** - Conceptual similarity via pgvector embeddings
+3. **text** - Fast fuzzy matching via pg_trgm
+4. **phrase** - Multi-word exact matching via PostgreSQL full-text search
+
+**Metadata Filtering**:
+- Filter by any metadata field: `{taskId: "...", area: "...", file: "..."}`
+- Essential for RLM task isolation and sub-agent context management
+
+**Performance** (10K memories):
+- Phrase search: ~30ms
+- Text search: ~15ms
+- Semantic search: ~25ms
+- Hybrid search: ~45ms
+- +10ms per metadata filter
+
+### Pricing Tiers
+
+- **Free**: 1,000 memories, 100 searches/day
+- **Starter** (£9/mo): 10,000 memories, 1,000 searches/day
+- **Pro** (£29/mo): 100,000 memories, 10,000 searches/day
+- **Enterprise** (£99/mo): 1M memories, unlimited searches
+
+### Documentation
+
+- Comprehensive README with setup instructions
+- Recursive Analyst agent template with RLM patterns
+- Tool-specific configuration for each supported editor
+- Examples for all search modes and metadata filtering
+
+[1.0.0]: https://github.com/radicalgeek/rembr-client/releases/tag/v1.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,248 @@
+# @rembr/vscode
+
+**Recursive Language Model (RLM) patterns for VS Code and GitHub Copilot**
+
+Transform your AI-assisted development with automatic task decomposition, achieving **51% token efficiency** improvements for complex coding tasks.
+
+## Quick Start
+
+```bash
+npm install -g @rembr/vscode
+rembr-vscode-setup
+```
+
+**What happens next?**
+
+✅ GitHub Copilot automatically detects complex tasks  
+✅ Recursive decomposition with focused subagents  
+✅ Semantic memory integration via rembr MCP  
+✅ 51% reduction in token usage for complex requests  
+✅ Complete documentation and workflow helpers  
+
+## How It Works
+
+### Before: Traditional Approach
+```
+User: "Implement rate limiting for payment service with Redis, auth, monitoring, and tests"
+
+Copilot: [Loads entire codebase context → 12,847 tokens → Single massive response]
+Result: Incomplete implementation, missing edge cases, 4 revisions needed
+```
+
+### After: RLM Patterns
+```
+User: "Implement rate limiting for payment service with Redis, auth, monitoring, and tests"
+
+Copilot: [Auto-detects complexity → Spawns focused subagents]
+├── L1-Analysis: Analyze payment endpoints (280 tokens)
+├── L1-Design: Design Redis strategy (180 tokens)  
+├── L1-Implementation: Build middleware (350 tokens)
+└── L1-Monitoring: Add metrics/tests (120 tokens)
+
+Result: Complete implementation, 6,241 tokens (51% reduction), 1 revision
+```
+
+The installer automatically configures:
+
+### 🧠 GitHub Copilot Integration
+- **`.github/copilot-instructions.md`** - Auto-detection triggers for complex tasks
+- **`.github/agents/recursive-analyst.agent.md`** - Specialized RLM agent
+- **Pattern Recognition** - Automatically identifies when to decompose tasks
+
+### 📡 MCP Memory Integration  
+- **VS Code settings** - REMBR MCP server configuration
+- **Semantic Memory** - Persistent context across sessions
+- **Cross-project Learning** - Reuse patterns between projects
+
+### 🛠 Workflow Tools
+- **`rlm-helper.js`** - Task coordination and analysis script
+- **`docs/rlm-patterns.md`** - Complete usage guide  
+- **`docs/rlm-benchmarks.md`** - Performance analysis
+
+## Auto-Detection Examples
+
+### ✅ Complex Tasks (Auto-RLM)
+These requests automatically trigger recursive decomposition:
+
+```javascript
+// Multi-component implementations
+"Implement OAuth2 with JWT refresh tokens, rate limiting, and admin dashboard"
+
+// Cross-service integrations  
+"Migrate user service to microservices with message queues and monitoring"
+
+// Architecture changes
+"Refactor monolith payment system for scalability and add caching"
+
+// Analysis + implementation
+"Analyze current auth flow and rebuild with SSO integration"
+```
+
+### 🎯 Simple Tasks (Standard)
+These use traditional single-shot responses:
+
+```javascript
+// Single file changes
+"Fix this TypeScript type error"
+"Add logging to this function"  
+"Update README with new installation steps"
+"Rename variable from userID to userId"
+```
+
+## Performance Benefits
+
+| Complexity | Traditional Tokens | RLM Tokens | Reduction | Quality Gain |
+|------------|-------------------|------------|-----------|--------------|
+| **High** | 18,400 | 8,800 | **52%** | +2.5 points |
+| **Medium** | 8,200 | 4,900 | **40%** | +1.8 points |
+| **Low** | 2,100 | 2,100 | **0%** | No change |
+
+### Why RLM Works
+
+1. **Focused Context** - Each subagent receives only relevant code/memories
+2. **Parallel Processing** - Multiple specialized agents work simultaneously  
+3. **Persistent Learning** - Solutions stored in semantic memory for reuse
+4. **Incremental Validation** - Each level validates before proceeding
+
+## Memory Categories
+
+RLM automatically organizes knowledge:
+
+- **`facts`** - Code patterns, implementation details, technical specifications
+- **`context`** - Session coordination, task decomposition metadata
+- **`projects`** - High-level summaries, architectural decisions
+
+## Usage Examples
+
+### Automatic Pattern Recognition
+
+```bash
+# Analyze any task for RLM suitability
+node rlm-helper.js "implement microservice with auth and monitoring"
+
+# Output:
+# 🧠 RLM PATTERN DETECTED - Complex task requiring decomposition
+# 📋 Generated TaskId: microservice-20260107-abc12  
+# 🔍 Key Concepts: microservice, auth, monitoring, api, service
+# 🏗️ Suggested Decomposition:
+#    1. L1-Analysis: Analyze current architecture and requirements
+#    2. L1-Design: Design service interfaces and auth strategy
+#    3. L1-Implementation: Build core service and endpoints
+#    4. L1-Monitoring: Add logging, metrics, and health checks
+```
+
+### Memory Integration
+
+```javascript
+// RLM automatically stores and retrieves context
+search_memory({ 
+  query: "rate limiting patterns express", 
+  category: "facts",
+  limit: 5 
+});
+
+// Find related implementations
+find_similar_memories({
+  memory_id: "auth-implementation-xyz",
+  min_similarity: 0.8,
+  limit: 3
+});
+```
+
+## Configuration
+
+### Set API Key
+
+After installation, configure your rembr API key:
+
+1. **Get API Key**: Visit [rembr.ai/dashboard/settings](https://rembr.ai/dashboard/settings)
+2. **VS Code Settings**: `Cmd+,` → Extensions → MCP → `rembr.env.REMBR_API_KEY`
+3. **Reload VS Code**: `Cmd+Shift+P` → "Developer: Reload Window"
+
+### Customize Patterns
+
+Edit `.github/copilot-instructions.md` to adjust:
+- Auto-detection triggers
+- Decomposition strategies
+- Memory categories  
+- Subagent specializations
+
+## Advanced Usage
+
+### Custom Agents
+
+Create domain-specific agents in `.github/agents/`:
+
+```markdown
+---
+name: Payment Service Expert
+description: Specialized in payment processing and financial integrations  
+tools:
+  - rembr/*
+  - codebase
+model: Claude Sonnet 4
+---
+
+You handle payment system tasks using RLM patterns.
+Auto-decompose into: security, processing, webhooks, compliance.
+```
+
+### Manual Subagent Spawning
+
+For fine-grained control:
+
+```javascript
+// Spawn specialized subagent
+runSubagent({
+  description: "Implement Redis rate limiting middleware",
+  prompt: `
+    ## Task  
+    Create express-rate-limit middleware with Redis store
+    
+    ## Context from Memory
+    ${await search_memory({query: "rate limiting redis patterns"})}
+    
+    ## Storage Instructions
+    Store findings with metadata: {"taskId": "rate-limit-20260107", "area": "middleware"}
+  `
+});
+```
+
+## Troubleshooting
+
+### Memory Not Persisting
+```bash
+# Check MCP connection
+curl -H "X-API-Key: YOUR_KEY" https://rembr.ai/health
+
+# Verify VS Code settings  
+code ~/.vscode/settings.json
+```
+
+### Auto-Detection Not Working
+1. Ensure `.github/copilot-instructions.md` exists in project root
+2. Restart GitHub Copilot: `Cmd+Shift+P` → "GitHub Copilot: Restart Extension"
+3. Use more explicit complexity indicators in your requests
+
+### Subagent Failures
+- Check task complexity (max 3 decomposition levels)
+- Ensure focused, actionable subtasks
+- Verify proper metadata in memory storage
+
+## Getting Support
+
+- **Documentation**: [docs.rembr.ai/rlm-patterns](https://docs.rembr.ai/rlm-patterns)
+- **Examples**: Browse with `search_memory({query: "implementation example"})`
+- **Community**: [GitHub Discussions](https://github.com/rembr-ai/community/discussions)
+- **Issues**: [GitHub Issues](https://github.com/rembr-ai/vscode-extension/issues)
+
+## License
+
+MIT - see [LICENSE](LICENSE) for details.
+
+---
+
+**Version**: 1.0.0  
+**Compatibility**: GitHub Copilot, VS Code, Claude Desktop  
+**Memory Backend**: [rembr.ai](https://rembr.ai) (hosted) or self-hosted  
+**Token Efficiency**: Up to 55% reduction for complex development tasks

package/cli.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+const { setup } = require('./setup');
+
+console.log('🫐 REMBR VS Code RLM Pattern Setup');
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+switch (command) {
+  case 'setup':
+  case 'init':
+    console.log('Setting up GitHub Copilot with recursive language model patterns...\n');
+    setup(true);
+    break;
+  
+  case 'help':
+  case '--help':
+  case '-h':
+    console.log(`
+� REMBR VS Code RLM Patterns - Recursive Language Model setup for GitHub Copilot
+
+Usage:
+  npx @rembr/vscode setup    Configure RLM patterns in your project
+  npx @rembr/vscode help     Show this help message
+
+What it does:
+  • Adds GitHub Copilot instructions for automatic task decomposition
+  • Creates Recursive Analyst agent for complex tasks
+  • Configures REMBR MCP server for semantic memory
+  • Adds RLM helper scripts and documentation
+
+Benefits:
+  • 51% token efficiency improvement for complex tasks
+  • Automatic detection of decomposition-worthy tasks
+  • Persistent semantic memory across sessions
+  • Focused subagent coordination
+
+Get started:
+  1. Run: npx @rembr/vscode setup
+  2. Get API key: https://rembr.ai/dashboard/settings
+  3. Configure in VS Code: Settings → MCP → rembr.env.REMBR_API_KEY
+  4. Reload VS Code and try a complex task
+
+Learn more: https://docs.rembr.ai/rlm-patterns
+`);
+    break;
+  
+  default:
+    if (!command) {
+      setup(true);
+    } else {
+      console.error(`Unknown command: ${command}`);
+      console.log('Run `npx @rembr/vscode help` for usage information');
+      process.exit(1);
+    }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@rembr/vscode",
+  "version": "1.0.0",
+  "description": "VS Code setup for REMBR RLM patterns - semantic memory for AI agents with GitHub Copilot recursive workflows",
+  "main": "setup.js",
+  "bin": {
+    "rembr-vscode": "./cli.js"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.js"
+  },
+  "files": [
+    "cli.js",
+    "postinstall.js",
+    "setup.js",
+    "templates/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "vscode",
+    "github-copilot",
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "memory",
+    "rlm",
+    "recursive-language-model",
+    "agents",
+    "semantic",
+    "rembr",
+    "recursive-learning-machine",
+    "agent",
+    "copilot",
+    "cursor",
+    "windsurf",
+    "claude",
+    "aider",
+    "semantic-memory",
+    "ai-memory",
+    "vector-database",
+    "embeddings",
+    "ai-agent",
+    "multi-agent",
+    "pgvector",
+    "context-management"
+  ],
+  "author": "REMBR <hello@rembr.ai>",
+  "license": "MIT",
+  "homepage": "https://rembr.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/radicalgeek/rembr-client.git"
+  },
+  "bugs": {
+    "url": "https://github.com/radicalgeek/rembr-client/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/postinstall.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+const { setup } = require('./setup');
+const path = require('path');
+const fs = require('fs');
+
+// Always run setup on postinstall, unless we're being installed globally
+const isGlobalInstall = process.env.npm_config_global === 'true';
+
+if (!isGlobalInstall) {
+  console.log('\n📦 Running REMBR postinstall setup...');
+  console.log('Current working directory:', process.cwd());
+  console.log('Package directory:', __dirname);
+  
+  // Find the project root - look for nearest package.json that isn't us
+  let projectRoot = process.cwd();
+  const packageDir = path.resolve(__dirname, '../../../'); // Go up from node_modules/@rembr/client
+  
+  // Check if we're in a node_modules directory and use parent project
+  if (process.cwd().includes('node_modules')) {
+    projectRoot = packageDir;
+  }
+  
+  console.log('Project root:', projectRoot);
+  
+  // Change to project directory before running setup
+  process.chdir(projectRoot);
+  setup(false);
+} else {
+  console.log('\n📦 @rembr/client installed globally. Run `npx rembr setup` to configure a project.\n');
+}