@rembr/vscode 1.0.0

package/setup.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const MCP_CONFIG = {
+  servers: {
+    rembr: {
+      url: "https://rembr.ai/mcp",
+      type: "http"
+    }
+  },
+  inputs: []
+};
+
+function ensureDirectoryExists(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function setupMCPConfig(projectRoot, toolDir, configFile) {
+  const toolConfigDir = path.join(projectRoot, toolDir);
+  const mcpConfigPath = path.join(toolConfigDir, configFile);
+  
+  ensureDirectoryExists(toolConfigDir);
+  
+  let config = MCP_CONFIG;
+  
+  // Merge with existing config if it exists
+  if (fs.existsSync(mcpConfigPath)) {
+    try {
+      const existingConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
+      config = {
+        ...existingConfig,
+        servers: {
+          ...existingConfig.servers,
+          rembr: MCP_CONFIG.servers.rembr
+        },
+        inputs: existingConfig.inputs || []
+      };
+      console.log(`✓ Updated existing ${toolDir}/${configFile} with REMBR server`);
+    } catch (error) {
+      console.warn(`⚠ Could not parse existing ${configFile}, creating new file`);
+    }
+  } else {
+    console.log(`✓ Created ${toolDir}/${configFile} with REMBR server`);
+  }
+  
+  fs.writeFileSync(mcpConfigPath, JSON.stringify(config, null, 2));
+}
+
+function setupVSCodeMCP(projectRoot) {
+  setupMCPConfig(projectRoot, '.vscode', 'mcp.json');
+}
+
+function setupCursorMCP(projectRoot) {
+  setupMCPConfig(projectRoot, '.cursor', 'mcp.json');
+}
+
+function setupWindsurfMCP(projectRoot) {
+  setupMCPConfig(projectRoot, '.windsurf', 'mcp.json');
+}
+
+function setupClaudeDesktopMCP() {
+  const homeDir = os.homedir();
+  let configPath;
+  
+  if (process.platform === 'darwin') {
+    configPath = path.join(homeDir, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  } else if (process.platform === 'win32') {
+    configPath = path.join(homeDir, 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json');
+  } else {
+    configPath = path.join(homeDir, '.config', 'Claude', 'claude_desktop_config.json');
+  }
+  
+  const configDir = path.dirname(configPath);
+  
+  if (!fs.existsSync(configDir)) {
+    console.log('⚠ Claude Desktop not found, skipping');
+    return;
+  }
+  
+  ensureDirectoryExists(configDir);
+  
+  let config = { mcpServers: {} };
+  
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (!config.mcpServers) config.mcpServers = {};
+    } catch (error) {
+      console.warn('⚠ Could not parse Claude Desktop config');
+    }
+  }
+  
+  config.mcpServers.rembr = {
+    url: "https://rembr.ai/mcp",
+    type: "http"
+  };
+  
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log('✓ Updated Claude Desktop config with REMBR server');
+}
+
+function setupGitHubCopilotAgent(projectRoot) {
+  const githubDir = path.join(projectRoot, '.github');
+  const agentsDir = path.join(githubDir, 'agents');
+  const agentPath = path.join(agentsDir, 'recursive-analyst.agent.md');
+  
+  ensureDirectoryExists(agentsDir);
+  
+  const templatePath = path.join(__dirname, 'templates', 'recursive-analyst.agent.md');
+  const agentContent = fs.readFileSync(templatePath, 'utf8');
+  
+  if (fs.existsSync(agentPath)) {
+    console.log('⚠ .github/agents/recursive-analyst.agent.md already exists, skipping');
+    return;
+  }
+  
+  fs.writeFileSync(agentPath, agentContent);
+  console.log('✓ Created .github/agents/recursive-analyst.agent.md');
+}
+
+function setupGitHubCopilotInstructions(projectRoot) {
+  const githubDir = path.join(projectRoot, '.github');
+  const instructionsPath = path.join(githubDir, 'copilot-instructions.md');
+  
+  ensureDirectoryExists(githubDir);
+  
+  const templatePath = path.join(__dirname, 'templates', 'copilot-instructions.md');
+  const instructionsContent = fs.readFileSync(templatePath, 'utf8');
+  
+  if (fs.existsSync(instructionsPath)) {
+    console.log('⚠ .github/copilot-instructions.md already exists, skipping');
+    return;
+  }
+  
+  fs.writeFileSync(instructionsPath, instructionsContent);
+  console.log('✓ Created .github/copilot-instructions.md with RLM patterns');
+}
+
+function setupRLMHelper(projectRoot) {
+  const helperPath = path.join(projectRoot, 'rlm-helper.js');
+  const templatePath = path.join(__dirname, 'templates', 'rlm-helper.js');
+  
+  if (fs.existsSync(helperPath)) {
+    console.log('⚠ rlm-helper.js already exists, skipping');
+    return;
+  }
+  
+  fs.copyFileSync(templatePath, helperPath);
+  fs.chmodSync(helperPath, '755'); // Make executable
+  console.log('✓ Created rlm-helper.js for task coordination');
+}
+
+function setupRLMDocumentation(projectRoot) {
+  const docsDir = path.join(projectRoot, 'docs');
+  ensureDirectoryExists(docsDir);
+  
+  // RLM Getting Started Guide
+  const gettingStartedPath = path.join(docsDir, 'rlm-patterns.md');
+  if (!fs.existsSync(gettingStartedPath)) {
+    const templatePath = path.join(__dirname, 'templates', 'rlm-getting-started.md');
+    fs.copyFileSync(templatePath, gettingStartedPath);
+    console.log('✓ Created docs/rlm-patterns.md');
+  }
+  
+  // Benchmark Results
+  const benchmarkPath = path.join(docsDir, 'rlm-benchmarks.md');
+  if (!fs.existsSync(benchmarkPath)) {
+    const templatePath = path.join(__dirname, 'templates', 'rlm-benchmarks.md');
+    fs.copyFileSync(templatePath, benchmarkPath);
+    console.log('✓ Created docs/rlm-benchmarks.md');
+  }
+}
+
+function setupCursorRules(projectRoot) {
+  const cursorRulesPath = path.join(projectRoot, '.cursorrules');
+  const templatePath = path.join(__dirname, 'templates', 'cursorrules');
+  
+  if (fs.existsSync(cursorRulesPath)) {
+    // Append REMBR section if not already present
+    const existing = fs.readFileSync(cursorRulesPath, 'utf8');
+    if (existing.includes('REMBR') || existing.includes('rembr')) {
+      console.log('⚠ .cursorrules already contains REMBR instructions, skipping');
+      return;
+    }
+    const template = fs.readFileSync(templatePath, 'utf8');
+    fs.writeFileSync(cursorRulesPath, existing + '\n\n' + template);
+    console.log('✓ Appended REMBR instructions to .cursorrules');
+  } else {
+    fs.copyFileSync(templatePath, cursorRulesPath);
+    console.log('✓ Created .cursorrules with REMBR instructions');
+  }
+}
+
+function setupWindsurfRules(projectRoot) {
+  const windsurfRulesPath = path.join(projectRoot, '.windsurfrules');
+  const templatePath = path.join(__dirname, 'templates', 'windsurfrules');
+  
+  if (fs.existsSync(windsurfRulesPath)) {
+    const existing = fs.readFileSync(windsurfRulesPath, 'utf8');
+    if (existing.includes('REMBR') || existing.includes('rembr')) {
+      console.log('⚠ .windsurfrules already contains REMBR instructions, skipping');
+      return;
+    }
+    const template = fs.readFileSync(templatePath, 'utf8');
+    fs.writeFileSync(windsurfRulesPath, existing + '\n\n' + template);
+    console.log('✓ Appended REMBR instructions to .windsurfrules');
+  } else {
+    fs.copyFileSync(templatePath, windsurfRulesPath);
+    console.log('✓ Created .windsurfrules with REMBR instructions');
+  }
+}
+
+function setupAiderConfig(projectRoot) {
+  const aiderConfigPath = path.join(projectRoot, '.aider.conf.yml');
+  const templatePath = path.join(__dirname, 'templates', 'aider.conf.yml');
+  
+  if (fs.existsSync(aiderConfigPath)) {
+    console.log('⚠ .aider.conf.yml already exists, skipping');
+    console.log('  Add these lines manually:');
+    console.log('  - Use REMBR for persistent semantic memory');
+    console.log('  - MCP server: https://rembr.ai/mcp');
+    return;
+  }
+  
+  fs.copyFileSync(templatePath, aiderConfigPath);
+  console.log('✓ Created .aider.conf.yml with REMBR instructions');
+}
+
+function setup(interactive = false) {
+  // Find project root (where package.json or .git exists)
+  let projectRoot = process.cwd();
+  
+  while (!fs.existsSync(path.join(projectRoot, 'package.json')) && 
+         !fs.existsSync(path.join(projectRoot, '.git')) && 
+         projectRoot !== '/') {
+    projectRoot = path.dirname(projectRoot);
+  }
+  
+  if (projectRoot === '/') {
+    projectRoot = process.cwd();
+  }
+  
+  console.log('\n🫐 Setting up REMBR client configuration...\n');
+  
+  try {
+    // Set up MCP for all supported tools
+    console.log('📡 Configuring MCP servers...');
+    setupVSCodeMCP(projectRoot);
+    setupCursorMCP(projectRoot);
+    setupWindsurfMCP(projectRoot);
+    setupClaudeDesktopMCP(); // Global config
+    
+    console.log('\n🤖 Configuring AI agents and RLM patterns...');
+    setupGitHubCopilotAgent(projectRoot);
+    setupGitHubCopilotInstructions(projectRoot);
+    setupRLMHelper(projectRoot);
+    setupRLMDocumentation(projectRoot);
+    
+    console.log('\n⚙️ Configuring legacy AI tools...');
+    setupCursorRules(projectRoot);
+    setupWindsurfRules(projectRoot);
+    setupAiderConfig(projectRoot);
+    
+    console.log('\n✨ @rembr/vscode setup complete!\n');
+    console.log('🧠 RLM Pattern System Installed:');
+    console.log('  • GitHub Copilot with auto-detection (51% token reduction)');
+    console.log('  • Recursive Analyst agent for complex tasks');
+    console.log('  • Semantic memory with rembr MCP integration');
+    console.log('  • Task coordination and workflow optimization');
+    console.log('\n📡 MCP Configured for:');
+    console.log('  • VS Code + GitHub Copilot');
+    console.log('  • Cursor');
+    console.log('  • Windsurf');
+    console.log('  • Claude Desktop');
+    console.log('  • Aider');
+    console.log('\n📖 Documentation Created:');
+    console.log('  • docs/rlm-patterns.md - Complete usage guide');
+    console.log('  • docs/rlm-benchmarks.md - Performance analysis');
+    console.log('  • rlm-helper.js - Task coordination script');
+    console.log('\nNext steps:');
+    console.log('1. Get your API key at https://rembr.ai/dashboard/settings');
+    console.log('2. Set REMBR_API_KEY in VS Code settings:');
+    console.log('   Settings → Extensions → MCP → rembr.env.REMBR_API_KEY');
+    console.log('3. Reload VS Code to activate RLM patterns');
+    console.log('4. Try a complex task like "implement rate limiting with Redis and monitoring"');
+    console.log('5. Watch GitHub Copilot automatically decompose into focused subagents\n');
+    console.log('💡 Tip: Use "node rlm-helper.js <task>" to analyze decomposition patterns\n');
+  } catch (error) {
+    console.error('❌ Setup failed:', error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { setup };
+
+// Run setup if called directly
+if (require.main === module) {
+  setup(true);
+}

package/templates/aider.conf.yml

@@ -0,0 +1,52 @@
+# Aider configuration with REMBR semantic memory
+
+# REMBR Integration
+# 
+# REMBR provides persistent semantic memory for your coding sessions.
+# While Aider doesn't natively support MCP, you can integrate REMBR via:
+#
+# 1. Manual tool calls in prompts:
+#    "First, search REMBR for authentication patterns, then implement..."
+#
+# 2. External scripts that call the REMBR API:
+#    curl -X POST https://rembr.ai/api/v1/search \
+#      -H "Authorization: Bearer $REMBR_API_KEY" \
+#      -d '{"query": "authentication patterns"}'
+#
+# 3. Pre/post hooks that store session context:
+#    - Before: Retrieve relevant context from REMBR
+#    - After: Store findings and decisions to REMBR
+
+# Model configuration
+model: claude-sonnet-4
+
+# Enable git integration
+auto-commits: true
+dirty-commits: true
+
+# Editor for commit messages
+editor: vim
+
+# Suggested workflow with REMBR:
+#
+# 1. Before starting: Query REMBR for relevant context
+#    $ rembr-query "database migration patterns"
+#
+# 2. During coding: Aider makes changes
+#
+# 3. After completing: Store findings to REMBR
+#    $ rembr-store "Migrated users table to support OAuth. Added provider column."
+#
+# You can create these wrapper scripts to integrate REMBR with Aider.
+
+# Example bash aliases for ~/.bashrc:
+#
+# alias rembr-query='curl -X POST https://rembr.ai/api/v1/search \
+#   -H "Authorization: Bearer $REMBR_API_KEY" \
+#   -H "Content-Type: application/json" \
+#   -d "{\"query\": \"$1\", \"limit\": 5}" | jq -r ".memories[].content"'
+#
+# alias rembr-store='curl -X POST https://rembr.ai/api/v1/memories \
+#   -H "Authorization: Bearer $REMBR_API_KEY" \
+#   -H "Content-Type: application/json" \
+#   -d "{\"content\": \"$1\", \"category\": \"facts\"}"'

package/templates/copilot-instructions.md

@@ -0,0 +1,49 @@
+<!-- Use this file to provide workspace-specific custom instructions to Copilot. For more details, visit https://code.visualstudio.com/docs/copilot/copilot-customization#_use-a-githubcopilotinstructionsmd-file -->
+
+This project uses the Recursive Language Model (RLM) pattern for complex tasks.
+
+## AUTOMATIC RLM PATTERN
+
+**When you detect a complex task (multiple steps, technologies, or cross-cutting concerns), AUTOMATICALLY:**
+
+1. **Generate taskId**: `${taskType}-${YYYYMMDD}-${randomId}`
+2. **Query rembr**: `search_memory({ query: "relevant keywords", limit: 5 })`
+3. **Spawn subagents**: Use `runSubagent` with retrieved context
+4. **Enable recursion**: Allow subagents to spawn their own subagents (max 3 levels)
+5. **Synthesize**: Coordinate hierarchical results and store to rembr
+
+### Auto-Detection Triggers
+- Multiple technologies: "React AND Go", "database AND API"
+- Cross-cutting: "refactor", "migrate", "convert", "integrate"  
+- Complex modifiers: "comprehensive", "full-stack", "end-to-end"
+- Multiple phases: "analyze and implement", "design and build"
+
+### Recursive Depth Management
+- **Level 0 (Root)**: Main task coordination
+- **Level 1**: Major component decomposition  
+- **Level 2**: Specialized implementation
+- **Level 3**: Micro-tasks and details
+- **Max Depth**: 3 levels to prevent infinite recursion
+
+### Example Auto-Execution
+**User**: "Refactor this React app to Go with authentication"
+**You**: 
+```javascript
+// Auto-detected complex task, executing RLM pattern
+const taskId = "react-go-auth-20260107-x9k2m";
+const context = await search_memory({ query: "React Go authentication patterns" });
+// Spawning 3 L1 subagents: analysis, conversion, auth
+// Each L1 agent may spawn L2 agents for specialized tasks
+// Max depth: 3 levels for complete decomposition
+```
+
+## Project Structure
+- Modern development practices with AI-assisted workflows
+- Clean, organized codebase with clear separation of concerns
+- Comprehensive documentation and testing
+
+## Development Guidelines
+- Break complex tasks into focused subtasks
+- Use semantic memory for context persistence
+- Follow established patterns and best practices
+- Maintain high code quality through automated decomposition

package/templates/cursorrules

@@ -0,0 +1,141 @@
+# REMBR - Recursive Language Model with Semantic Memory
+
+You have access to REMBR, a semantic memory system via MCP tools. Use it to implement the Recursive Language Model (RLM) pattern for complex tasks.
+
+## Core Principles
+
+1. **Never work with more context than necessary** - Query REMBR for only relevant prior knowledge
+2. **Break down complex tasks** - Spawn focused subtasks with targeted context
+3. **Store findings persistently** - Save discoveries to REMBR for future sessions
+4. **Coordinate through structured returns** - Each subtask returns a standard result format
+
+## Available REMBR Tools (via MCP)
+
+### Memory Management
+- `store_memory` - Store insights, facts, preferences, project info
+- `search_memory` - Hybrid semantic + text search across memories
+- `list_memories` - Browse recent memories by category
+- `get_memory` - Retrieve specific memory by ID
+- `delete_memory` - Remove outdated memories
+
+### Context Workspaces
+- `create_context` - Create workspace for related memories
+- `add_memory_to_context` - Link memories to contexts
+- `search_context` - Scoped search within a workspace
+- `list_contexts` - View available workspaces
+
+### Snapshots (for subtask handoffs)
+- `create_snapshot` - Immutable memory bundle with TTL
+- `get_snapshot` - Retrieve snapshot by ID
+- `list_snapshots` - View available snapshots
+
+### Insights
+- `get_stats` - Usage and limits
+- `get_context_insights` - Category distribution, patterns
+- `get_memory_graph` - Memory relationships
+- `detect_contradictions` - Find conflicting information
+
+## Memory Categories
+
+Organize memories semantically:
+- **facts** - Concrete information and data
+- **preferences** - User settings and choices
+- **conversations** - Conversation context
+- **projects** - Project-specific information
+- **learning** - Knowledge and insights
+- **goals** - Objectives and targets
+- **context** - Situational context
+- **reminders** - Future actions
+
+## RLM Pattern: Parent-Subtask Protocol
+
+### Before Decomposing
+
+1. Generate unique `taskId` (e.g., `implement-auth-20240106`)
+2. Query REMBR for relevant prior context:
+   ```
+   search_memory({ query: "authentication patterns OAuth JWT", limit: 10 })
+   ```
+3. Identify subtasks and what context each needs
+
+### When Spawning Subtasks
+
+Provide each subtask with:
+```
+## Subtask
+[Specific focused objective]
+
+## Context from REMBR
+[Relevant memories retrieved for this subtask]
+
+## Storage Instructions
+Store findings with:
+- Category: "facts"
+- Metadata: { "taskId": "implement-auth-20240106", "area": "oauth-flow" }
+
+## Return Format
+- Summary: [What you found/did]
+- Findings stored: [Search query to retrieve details]
+- Key points: [Most important items]
+- Status: [complete/partial/blocked]
+```
+
+### After Subtasks Complete
+
+1. Read each subtask's summary and key points
+2. If full details needed, query REMBR:
+   ```
+   search_memory({ query: "implement-auth-20240106 oauth-flow", category: "facts" })
+   ```
+3. Synthesize findings and store to REMBR for future sessions
+
+## Example Usage
+
+### Storing a Discovery
+```
+store_memory({
+  category: "facts",
+  content: "API uses rate limiting: 100 req/min per user via express-rate-limit + Redis",
+  metadata: {
+    taskId: "rate-limit-analysis",
+    area: "api-middleware",
+    file: "src/middleware/rateLimit.ts"
+  }
+})
+```
+
+### Retrieving Context
+```
+search_memory({
+  query: "rate limiting middleware patterns",
+  category: "facts",
+  limit: 5
+})
+```
+
+### Creating a Workspace
+```
+create_context({
+  name: "payment-service-refactor",
+  description: "Refactoring payment service to microservices",
+  category: "projects"
+})
+```
+
+## When to Use REMBR
+
+✅ **Do use** for:
+- Storing architectural decisions
+- Remembering project patterns and conventions
+- Building knowledge across sessions
+- Coordinating complex multi-step tasks
+- Sharing context between subtasks
+
+❌ **Don't use** for:
+- Temporary variables or transient data
+- Information already in the codebase
+- Simple single-step tasks
+
+## API Key Setup
+
+Ensure `REMBR_API_KEY` is set in your Cursor environment settings.