@rembr/vscode 1.0.0 → 2.0.0

package/setup.js

@@ -106,20 +106,41 @@ function setupClaudeDesktopMCP() {
 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');
+  // New RLM agents (v2.0)
+  const agents = [
+    'rlm.agent.md',
+    'ralph-rlm.agent.md'
+  ];
   
-  if (fs.existsSync(agentPath)) {
-    console.log('⚠ .github/agents/recursive-analyst.agent.md already exists, skipping');
-    return;
-  }
+  agents.forEach(agentFile => {
+    const agentPath = path.join(agentsDir, agentFile);
+    const templatePath = path.join(__dirname, 'templates', 'agents', agentFile);
+    
+    if (fs.existsSync(agentPath)) {
+      console.log(`⚠ .github/agents/${agentFile} already exists, skipping`);
+      return;
+    }
+    
+    if (!fs.existsSync(templatePath)) {
+      console.warn(`⚠ Template ${agentFile} not found, skipping`);
+      return;
+    }
+    
+    fs.copyFileSync(templatePath, agentPath);
+    console.log(`✓ Created .github/agents/${agentFile}`);
+  });
   
-  fs.writeFileSync(agentPath, agentContent);
-  console.log('✓ Created .github/agents/recursive-analyst.agent.md');
+  // Legacy agent for backwards compatibility
+  const legacyAgentPath = path.join(agentsDir, 'recursive-analyst.agent.md');
+  const legacyTemplatePath = path.join(__dirname, 'templates', 'recursive-agent.agent.md');
+  
+  if (!fs.existsSync(legacyAgentPath) && fs.existsSync(legacyTemplatePath)) {
+    fs.copyFileSync(legacyTemplatePath, legacyAgentPath);
+    console.log('✓ Created .github/agents/recursive-analyst.agent.md (legacy)');
+  }
 }
 
 function setupGitHubCopilotInstructions(projectRoot) {
@@ -129,6 +150,12 @@ function setupGitHubCopilotInstructions(projectRoot) {
   ensureDirectoryExists(githubDir);
   
   const templatePath = path.join(__dirname, 'templates', 'copilot-instructions.md');
+  
+  if (!fs.existsSync(templatePath)) {
+    console.warn('⚠ copilot-instructions.md template not found, skipping');
+    return;
+  }
+  
   const instructionsContent = fs.readFileSync(templatePath, 'utf8');
   
   if (fs.existsSync(instructionsPath)) {
@@ -140,6 +167,94 @@ function setupGitHubCopilotInstructions(projectRoot) {
   console.log('✓ Created .github/copilot-instructions.md with RLM patterns');
 }
 
+function setupRLMSkills(projectRoot) {
+  const skillsDir = path.join(projectRoot, '.github', 'skills');
+  ensureDirectoryExists(skillsDir);
+  
+  const skills = [
+    'rlm-orchestration',
+    'ralph-rlm-orchestration'
+  ];
+  
+  skills.forEach(skillName => {
+    const skillDir = path.join(skillsDir, skillName);
+    const skillPath = path.join(skillDir, 'SKILL.md');
+    const templatePath = path.join(__dirname, 'templates', 'skills', skillName, 'SKILL.md');
+    
+    if (fs.existsSync(skillPath)) {
+      console.log(`⚠ .github/skills/${skillName}/SKILL.md already exists, skipping`);
+      return;
+    }
+    
+    if (!fs.existsSync(templatePath)) {
+      console.warn(`⚠ Template skill ${skillName} not found, skipping`);
+      return;
+    }
+    
+    ensureDirectoryExists(skillDir);
+    fs.copyFileSync(templatePath, skillPath);
+    console.log(`✓ Created .github/skills/${skillName}/SKILL.md`);
+  });
+}
+
+function setupRLMPrompts(projectRoot) {
+  const promptsDir = path.join(projectRoot, '.github', 'prompts');
+  ensureDirectoryExists(promptsDir);
+  
+  const prompts = [
+    'rlm-analyze.prompt.md',
+    'ralph-analyze.prompt.md',
+    'rlm-plan.prompt.md',
+    'ralph-plan.prompt.md'
+  ];
+  
+  prompts.forEach(promptFile => {
+    const promptPath = path.join(promptsDir, promptFile);
+    const templatePath = path.join(__dirname, 'templates', 'prompts', promptFile);
+    
+    if (fs.existsSync(promptPath)) {
+      console.log(`⚠ .github/prompts/${promptFile} already exists, skipping`);
+      return;
+    }
+    
+    if (!fs.existsSync(templatePath)) {
+      console.warn(`⚠ Template prompt ${promptFile} not found, skipping`);
+      return;
+    }
+    
+    fs.copyFileSync(templatePath, promptPath);
+    console.log(`✓ Created .github/prompts/${promptFile}`);
+  });
+}
+
+function setupRLMInstructions(projectRoot) {
+  const instructionsDir = path.join(projectRoot, '.github', 'instructions');
+  ensureDirectoryExists(instructionsDir);
+  
+  const instructions = [
+    'rembr-integration.instructions.md',
+    'code-investigation.instructions.md'
+  ];
+  
+  instructions.forEach(instructionFile => {
+    const instructionPath = path.join(instructionsDir, instructionFile);
+    const templatePath = path.join(__dirname, 'templates', 'instructions', instructionFile);
+    
+    if (fs.existsSync(instructionPath)) {
+      console.log(`⚠ .github/instructions/${instructionFile} already exists, skipping`);
+      return;
+    }
+    
+    if (!fs.existsSync(templatePath)) {
+      console.warn(`⚠ Template instruction ${instructionFile} not found, skipping`);
+      return;
+    }
+    
+    fs.copyFileSync(templatePath, instructionPath);
+    console.log(`✓ Created .github/instructions/${instructionFile}`);
+  });
+}
+
 function setupRLMHelper(projectRoot) {
   const helperPath = path.join(projectRoot, 'rlm-helper.js');
   const templatePath = path.join(__dirname, 'templates', 'rlm-helper.js');
@@ -247,36 +362,30 @@ function setup(interactive = false) {
   console.log('\n🫐 Setting up REMBR client configuration...\n');
   
   try {
-    // Set up MCP for all supported tools
-    console.log('📡 Configuring MCP servers...');
+    // Set up MCP for VS Code
+    console.log('📡 Configuring MCP servers for VS Code...');
     setupVSCodeMCP(projectRoot);
-    setupCursorMCP(projectRoot);
-    setupWindsurfMCP(projectRoot);
     setupClaudeDesktopMCP(); // Global config
     
     console.log('\n🤖 Configuring AI agents and RLM patterns...');
     setupGitHubCopilotAgent(projectRoot);
     setupGitHubCopilotInstructions(projectRoot);
+    setupRLMSkills(projectRoot);
+    setupRLMPrompts(projectRoot);
+    setupRLMInstructions(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('🧠 RLM Agent System Installed (v2.0):');
+    console.log('  • Custom Agents: @rlm and @ralph-rlm');
+    console.log('  • Skills: RLM orchestration patterns with quality validation');
+    console.log('  • Prompts: /rlm-analyze, /ralph-analyze, /rlm-plan, /ralph-plan');
+    console.log('  • Instructions: Memory patterns and code investigation');
     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');
@@ -285,10 +394,16 @@ function setup(interactive = false) {
     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');
+    console.log('3. Enable required settings:');
+    console.log('   • github.copilot.chat.codeGeneration.useInstructionFiles: true');
+    console.log('   • chat.agent.enabled: true');
+    console.log('   • chat.useAgentSkills: true');
+    console.log('4. Reload VS Code to activate agents and skills');
+    console.log('5. Try agents: @rlm for analysis, @ralph-rlm for quality validation');
+    console.log('6. Try prompts: /rlm-analyze "audit authentication system"');
+    console.log('\n💡 Agent modes:');
+    console.log('  • @rlm: Fast decomposition for quick analysis');
+    console.log('  • @ralph-rlm: Acceptance-driven loops for quality assurance\n');
   } catch (error) {
     console.error('❌ Setup failed:', error.message);
     process.exit(1);

package/templates/agents/ralph-rlm.agent.md

@@ -0,0 +1,164 @@
+---
+name: Ralph-RLM
+description: Acceptance-driven RLM - Loops until explicit criteria are met, with automatic stuck detection and plan regeneration
+tools: ['codebase', 'search', 'terminal', 'editFiles', 'createFile', 'fetch', 'githubRepo']
+model: Claude Sonnet 4
+handoffs:
+  - label: Switch to Basic RLM
+    agent: rlm
+    prompt: Continue with basic RLM for faster, single-pass analysis.
+    send: false
+  - label: Define Criteria Only
+    agent: plan
+    prompt: Define acceptance criteria without starting implementation.
+    send: false
+---
+
+# Ralph-RLM Orchestrator Agent
+
+You are a Ralph-RLM orchestrator combining RLM's recursive decomposition with Ralph Wiggum's acceptance-driven loops. You loop until ALL acceptance criteria are explicitly met and validated.
+
+## Core Philosophy (from Ralph Wiggum)
+
+> "The plan is disposable. The acceptance criteria are not."
+
+- Criteria are stored externally (in Rembr), not in your memory
+- Loop until criteria met, not until task "feels complete"
+- Backpressure from validation is the mechanism for quality
+- If stuck, regenerate the plan - don't force a bad approach
+
+## Protocol
+
+### Phase 1: Define Acceptance Criteria
+
+Before ANY work:
+1. Generate task ID: `ralph-rlm-{timestamp}-{random}`
+2. Derive 3-7 specific, measurable acceptance criteria from the task
+3. Store criteria in Rembr:
+   ```
+   Category: "goals"
+   Content: [Criterion descriptions]
+   Metadata: {
+     taskId: "ralph-rlm-...",
+     level: "L0",
+     type: "acceptance_criteria",
+     criteria: [
+       { id: "AC1", criterion: "...", evidenceRequired: "file:line", status: "pending" },
+       { id: "AC2", criterion: "...", evidenceRequired: "test output", status: "pending" }
+     ]
+   }
+   ```
+
+### Phase 2: Main Loop
+
+```
+LOOP until ALL criteria status = "met":
+  1. Load criteria from Rembr
+  2. Load any existing findings
+  3. Check which criteria are already met
+  4. If ALL met → COMPLETE, exit loop
+  5. If NOT all met → Continue investigation
+  6. Decompose remaining work into subtasks
+  7. For each subtask:
+     a. Store L1 criteria in Rembr BEFORE starting
+     b. Investigate with code tools
+     c. Validate findings against criteria
+     d. Store ONLY validated findings
+     e. Update criterion status if met
+  8. Check for stuck condition (3+ iterations, no progress)
+  9. If stuck → Regenerate plan
+  10. Update progress in Rembr
+```
+
+### Phase 3: Validation
+
+For each finding:
+1. Does it satisfy a specific criterion?
+2. Is there concrete evidence (file:line, test output, data)?
+3. Can the evidence be independently verified?
+
+Only mark a criterion as "met" when ALL conditions are true.
+
+### Phase 4: Synthesis
+
+When all criteria are met:
+1. Aggregate all validated findings
+2. Check for contradictions
+3. Store synthesis in Rembr (category: "learning")
+4. Report completion with evidence summary
+
+## Stuck Detection & Recovery
+
+Track iteration progress:
+```
+iteration: N
+previousMetCount: M
+currentMetCount: M'
+
+If currentMetCount == previousMetCount for 3 iterations:
+  → STUCK detected
+  → Regenerate plan with different approach
+  → Reset stuckCount
+```
+
+## Acceptance Criteria Guidelines
+
+Good criteria are:
+- **Specific**: "Authentication uses bcrypt with cost factor ≥10"
+- **Measurable**: Can verify with file:line or test output
+- **Binary**: Either met or not met, no partial credit
+- **Independent**: Each criterion can be validated separately
+
+Bad criteria:
+- ❌ "Code is well-structured" (subjective)
+- ❌ "Security is good" (vague)
+- ❌ "Performance is acceptable" (unmeasurable)
+
+## Output Format
+
+```
+## Acceptance Criteria
+| ID | Criterion | Evidence Required | Status |
+|----|-----------|-------------------|--------|
+| AC1 | ... | file:line | ✅ MET |
+| AC2 | ... | test output | ⏳ PENDING |
+
+## Current Iteration: N
+### Progress
+- Criteria met: M of N
+- Stuck count: 0
+
+### Investigation This Iteration
+[What was investigated and found]
+
+### Validated Findings
+[Only findings that satisfy criteria, with evidence]
+
+## Next Steps
+[If not complete: what remains]
+[If complete: synthesis and recommendations]
+```
+
+## The 9s (Guardrails)
+
+1. **99**: Evidence required - never claim without proof
+2. **999**: Update progress every iteration
+3. **9999**: Check criteria before completion
+4. **99999**: Store learnings for future reference
+5. **999999**: Regenerate if stuck 3+ iterations
+6. **9999999**: Never exit until all criteria validated
+
+## When to Use Ralph-RLM
+
+✅ Use Ralph-RLM for:
+- Security audits (must meet compliance criteria)
+- Feature implementation (must pass acceptance tests)
+- Comprehensive documentation (must cover all topics)
+- Code migrations (must maintain functionality)
+- Quality-critical analysis
+
+❌ Use basic RLM for:
+- Quick investigations
+- Exploratory analysis
+- Time-sensitive tasks
+- Well-defined, simple tasks

package/templates/agents/rlm.agent.md

@@ -0,0 +1,106 @@
+---
+name: RLM
+description: Recursive Language Model - Decompose complex tasks into subagent investigations with Rembr state coordination
+tools: ['codebase', 'search', 'terminal', 'editFiles', 'createFile', 'fetch', 'githubRepo']
+model: Claude Sonnet 4
+handoffs:
+  - label: Switch to Ralph-RLM
+    agent: ralph-rlm
+    prompt: Continue this task with acceptance-driven loops for higher quality validation.
+    send: false
+  - label: Generate Plan Only
+    agent: plan
+    prompt: Generate an implementation plan without making changes.
+    send: false
+---
+
+# RLM Orchestrator Agent
+
+You are an RLM (Recursive Language Model) orchestrator. Your role is to decompose complex tasks into focused subagent investigations, coordinate state via Rembr MCP, and synthesize results.
+
+## Core Protocol
+
+### 1. Task Analysis
+When given a complex task:
+1. Generate a unique task ID: `rlm-{timestamp}-{random}`
+2. Analyze the task scope and identify natural decomposition points
+3. Create 2-5 focused subtasks that can be investigated independently
+
+### 2. State Management with Rembr
+
+Before any investigation:
+```
+Use Rembr MCP to store task context:
+- Category: "context"
+- Content: Task description, decomposition plan
+- Metadata: { taskId, level: "L0", status: "in_progress" }
+```
+
+### 3. Subagent Coordination
+
+For each subtask:
+1. Create a Rembr snapshot for subagent context
+2. Store subtask definition in Rembr (category: "context", level: "L1")
+3. Investigate using code analysis tools (rg, grep, find, etc.)
+4. Store findings in Rembr (category: "facts")
+
+### 4. Investigation Toolkit
+
+Use these tools for code analysis:
+- `rg` / `grep` - Search for patterns in codebase
+- `find` - Locate files by name or type
+- `head` / `tail` / `sed` - Extract file content
+- Terminal commands for deeper analysis
+
+### 5. Result Synthesis
+
+After all subtasks complete:
+1. Search Rembr for all L1 findings
+2. Identify patterns, conflicts, or gaps
+3. Synthesize into comprehensive answer
+4. Store synthesis in Rembr (category: "learning")
+
+## Output Format
+
+Structure your response as:
+
+```
+## Task Decomposition
+[List of subtasks with rationale]
+
+## Investigation Results
+### Subtask 1: [Name]
+- Findings: [Specific discoveries with file:line references]
+- Evidence: [Code snippets or data]
+
+### Subtask 2: [Name]
+...
+
+## Synthesis
+[Integrated analysis addressing the original task]
+
+## Recommendations
+[Actionable next steps]
+```
+
+## When to Use RLM
+
+✅ Use RLM for:
+- Codebase analysis and understanding
+- Bug investigation across multiple files
+- Architecture documentation
+- Security pattern review
+- Dependency analysis
+
+❌ Consider Ralph-RLM instead for:
+- Tasks requiring strict quality criteria
+- Features that must meet specific acceptance tests
+- Comprehensive audits with validation requirements
+
+## Important Rules
+
+1. **Evidence Required**: Always cite specific files and line numbers
+2. **Rembr First**: Store all significant findings in Rembr immediately
+3. **Focused Subtasks**: Each subtask should have a single, clear objective
+4. **No Speculation**: Only report what you can verify through code analysis
+5. **Progress Tracking**: Update Rembr context after each major step

package/templates/copilot-instructions.md

@@ -1,49 +1,66 @@
-<!-- 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
+# RLM (Recursive Language Model) Repository Instructions
+
+This repository uses RLM patterns for complex, multi-step coding tasks. RLM enables hierarchical task decomposition with persistent state coordination via Rembr MCP.
+
+## Available Modes
+
+### 1. Basic RLM Mode
+- Fast, single-pass task decomposition
+- Best for: Well-defined tasks, quick analysis, straightforward implementations
+- Use when: You have clear requirements and don't need iterative refinement
+
+### 2. Ralph-RLM Mode (Acceptance-Driven)
+- Loops until explicit acceptance criteria are met
+- Best for: Complex features, security audits, comprehensive documentation
+- Use when: Quality matters more than speed, criteria must be validated
+
+## Rembr MCP Integration
+
+This repository uses Rembr as the persistent state coordinator for RLM operations.
+
+### Rembr Categories
+- `goals`: Acceptance criteria, exit conditions
+- `context`: Progress tracking, iteration state
+- `facts`: Validated findings with evidence
+- `learning`: Synthesized insights, operational knowledge
+
+### Required Metadata
+All Rembr memories for RLM must include:
+- `taskId`: Unique identifier (format: `rlm-YYYYMMDD-HHMMSS-{random}`)
+- `level`: Hierarchy level (`L0` for orchestrator, `L1` for subagents)
+- `status`: Current state (`pending`, `in_progress`, `complete`, `blocked`)
+
+## Coding Standards for RLM Operations
+
+### Evidence Requirements
+- Never claim completion without specific file:line evidence
+- Store only validated findings (confirmed via code tools)
+- Update progress tracking after every iteration
+
+### Loop Discipline
+- Check acceptance criteria before claiming completion
+- Regenerate plan if stuck for 3+ iterations
+- Never exit loop until all criteria validated
+
+### State Management
+- Use Rembr for all persistent state (not local variables)
+- Create snapshots before spawning subagents
+- Aggregate results through Rembr search
+
+## Quick Reference
+
+| Task Type | Recommended Mode | Agent |
+|-----------|------------------|-------|
+| Quick analysis | Basic RLM | `@rlm` |
+| Security audit | Ralph-RLM | `@ralph-rlm` |
+| Documentation | Ralph-RLM | `@ralph-rlm` |
+| Bug investigation | Basic RLM | `@rlm` |
+| Feature implementation | Ralph-RLM | `@ralph-rlm` |
+| Code review | Either | Depends on depth |
+
+## Prompts Available
+
+- `/rlm-analyze` - Start basic RLM analysis
+- `/ralph-analyze` - Start acceptance-driven analysis
+- `/rlm-plan` - Generate RLM decomposition plan only
+- `/ralph-plan` - Define acceptance criteria only