@stackmemoryai/stackmemory 0.3.22 → 0.3.25

package/scripts/ralph-loop-implementation.js

@@ -0,0 +1,404 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+class RalphLoop {
+  constructor(options = {}) {
+    this.baseDir = options.baseDir || '.ralph';
+    this.maxIterations = options.maxIterations || 50;
+    this.verbose = options.verbose || false;
+    
+    this.paths = {
+      task: path.join(this.baseDir, 'task.md'),
+      criteria: path.join(this.baseDir, 'completion-criteria.md'),
+      iteration: path.join(this.baseDir, 'iteration.txt'),
+      feedback: path.join(this.baseDir, 'feedback.txt'),
+      state: path.join(this.baseDir, 'state.json'),
+      complete: path.join(this.baseDir, 'work-complete.txt'),
+      progress: path.join(this.baseDir, 'progress.jsonl'),
+      history: path.join(this.baseDir, 'history')
+    };
+  }
+
+  async initialize(task, criteria) {
+    // Create directory structure
+    fs.mkdirSync(this.baseDir, { recursive: true });
+    fs.mkdirSync(this.paths.history, { recursive: true });
+    
+    // Initialize files
+    fs.writeFileSync(this.paths.task, task);
+    fs.writeFileSync(this.paths.criteria, criteria);
+    fs.writeFileSync(this.paths.iteration, '0');
+    fs.writeFileSync(this.paths.feedback, '');
+    
+    // Initial state
+    const state = {
+      startTime: Date.now(),
+      task: task.substring(0, 100),
+      status: 'initialized'
+    };
+    fs.writeFileSync(this.paths.state, JSON.stringify(state, null, 2));
+    
+    this.log('Ralph Loop initialized');
+  }
+
+  async runWorkerIteration() {
+    const iteration = this.getCurrentIteration();
+    const task = fs.readFileSync(this.paths.task, 'utf8');
+    const feedback = this.getFeedback();
+    
+    this.log(`Worker iteration ${iteration} starting...`);
+    
+    // Step 1: Analyze current state (fresh context)
+    const analysis = await this.analyzeCurrentState();
+    
+    // Step 2: Plan based on task and feedback
+    const plan = await this.createPlan(task, feedback, analysis);
+    
+    // Step 3: Execute changes
+    const changes = await this.executeChanges(plan);
+    
+    // Step 4: Validate changes
+    const validation = await this.validateChanges();
+    
+    // Step 5: Save iteration artifacts
+    await this.saveIterationArtifacts(iteration, {
+      analysis,
+      plan,
+      changes,
+      validation
+    });
+    
+    // Step 6: Commit changes
+    this.commitChanges(iteration, plan.summary);
+    
+    return {
+      iteration,
+      changes: changes.length,
+      validation
+    };
+  }
+
+  async runReviewerIteration() {
+    const iteration = this.getCurrentIteration();
+    const task = fs.readFileSync(this.paths.task, 'utf8');
+    const criteria = fs.readFileSync(this.paths.criteria, 'utf8');
+    
+    this.log(`Reviewer iteration ${iteration} evaluating...`);
+    
+    // Fresh evaluation of current state
+    const evaluation = await this.evaluateAgainstCriteria(criteria);
+    
+    if (evaluation.complete) {
+      fs.writeFileSync(this.paths.complete, 'true');
+      this.log('Task completed successfully!');
+      return { complete: true };
+    }
+    
+    // Generate feedback for next iteration
+    const feedback = this.generateFeedback(evaluation);
+    fs.writeFileSync(this.paths.feedback, feedback);
+    
+    // Increment iteration
+    this.incrementIteration();
+    
+    return {
+      complete: false,
+      feedback: feedback.substring(0, 200)
+    };
+  }
+
+  async analyzeCurrentState() {
+    // Simulate fresh analysis of codebase
+    const files = this.scanRelevantFiles();
+    const tests = this.getTestStatus();
+    const lastCommit = this.getLastCommit();
+    
+    return {
+      filesCount: files.length,
+      testsPass: tests.passing,
+      testsFail: tests.failing,
+      lastChange: lastCommit
+    };
+  }
+
+  async createPlan(_task, feedback, _analysis) {
+    // In real implementation, this would use an LLM
+    // Here we simulate planning based on feedback
+    const needsWork = feedback.includes('failing') || 
+                      feedback.includes('incomplete') ||
+                      feedback === '';
+    
+    return {
+      summary: `Iteration work based on: ${feedback.substring(0, 50)}`,
+      steps: needsWork ? ['Fix issues', 'Add features', 'Update tests'] : ['Polish'],
+      priority: needsWork ? 'high' : 'low'
+    };
+  }
+
+  async executeChanges(plan) {
+    // Simulate making code changes
+    const changes = [];
+    
+    for (const step of plan.steps) {
+      changes.push({
+        step,
+        timestamp: Date.now(),
+        result: 'simulated'
+      });
+    }
+    
+    return changes;
+  }
+
+  async validateChanges() {
+    // Run tests and checks
+    try {
+      const testResult = this.runTests();
+      const lintResult = this.runLint();
+      
+      return {
+        testsPass: testResult.passing > 0,
+        lintClean: lintResult.clean,
+        errors: [...testResult.errors, ...lintResult.errors]
+      };
+    } catch (error) {
+      return {
+        testsPass: false,
+        lintClean: false,
+        errors: [error.message]
+      };
+    }
+  }
+
+  async evaluateAgainstCriteria(criteria) {
+    // Parse criteria and check each
+    const criteriaLines = criteria.split('\n').filter(l => l.trim().startsWith('-'));
+    const results = {};
+    
+    for (const criterion of criteriaLines) {
+      const key = criterion.replace('-', '').trim().substring(0, 20);
+      // Simulate checking (in reality would analyze code)
+      results[key] = Math.random() > 0.3; // 70% chance of meeting each criterion
+    }
+    
+    const complete = Object.values(results).every(v => v === true);
+    
+    return {
+      complete,
+      criteria: results,
+      unmet: Object.entries(results)
+        .filter(([_, v]) => !v)
+        .map(([k]) => k)
+    };
+  }
+
+  generateFeedback(evaluation) {
+    if (evaluation.unmet.length === 0) {
+      return 'All criteria met';
+    }
+    
+    return `Still need to address:\n${evaluation.unmet.map(c => `- ${c}`).join('\n')}`;
+  }
+
+  async saveIterationArtifacts(iteration, artifacts) {
+    const iterDir = path.join(this.paths.history, `iteration-${String(iteration).padStart(3, '0')}`);
+    fs.mkdirSync(iterDir, { recursive: true });
+    
+    fs.writeFileSync(
+      path.join(iterDir, 'artifacts.json'),
+      JSON.stringify(artifacts, null, 2)
+    );
+    
+    // Log progress
+    const progress = {
+      iteration,
+      timestamp: Date.now(),
+      changes: artifacts.changes.length,
+      validation: artifacts.validation.testsPass,
+      errors: artifacts.validation.errors.length
+    };
+    
+    fs.appendFileSync(this.paths.progress, JSON.stringify(progress) + '\n');
+  }
+
+  commitChanges(iteration, summary) {
+    try {
+      execSync('git add -A', { stdio: 'pipe' });
+      execSync(`git commit -m "Ralph iteration ${iteration}: ${summary}" --allow-empty`, { stdio: 'pipe' });
+      this.log(`Committed iteration ${iteration}`);
+    } catch (error) {
+      this.log(`Commit failed: ${error.message}`);
+    }
+  }
+
+  scanRelevantFiles() {
+    // Simulate file scanning
+    return ['index.js', 'auth.js', 'test.js'];
+  }
+
+  getTestStatus() {
+    try {
+      execSync('npm test', { stdio: 'pipe' });
+      return { passing: 5, failing: 0 };
+    } catch {
+      return { passing: 3, failing: 2 };
+    }
+  }
+
+  runTests() {
+    const status = this.getTestStatus();
+    return {
+      passing: status.passing,
+      failing: status.failing,
+      errors: status.failing > 0 ? ['Some tests failed'] : []
+    };
+  }
+
+  runLint() {
+    try {
+      execSync('npm run lint', { stdio: 'pipe' });
+      return { clean: true, errors: [] };
+    } catch {
+      return { clean: false, errors: ['Lint issues found'] };
+    }
+  }
+
+  getLastCommit() {
+    try {
+      return execSync('git log -1 --oneline', { encoding: 'utf8' }).trim();
+    } catch {
+      return 'No commits yet';
+    }
+  }
+
+  getCurrentIteration() {
+    try {
+      return parseInt(fs.readFileSync(this.paths.iteration, 'utf8'));
+    } catch {
+      return 0;
+    }
+  }
+
+  incrementIteration() {
+    const current = this.getCurrentIteration();
+    fs.writeFileSync(this.paths.iteration, String(current + 1));
+  }
+
+  getFeedback() {
+    try {
+      return fs.readFileSync(this.paths.feedback, 'utf8');
+    } catch {
+      return '';
+    }
+  }
+
+  isComplete() {
+    return fs.existsSync(this.paths.complete);
+  }
+
+  log(message) {
+    if (this.verbose) {
+      console.log(`[Ralph] ${message}`);
+    }
+  }
+
+  async run() {
+    while (!this.isComplete()) {
+      const iteration = this.getCurrentIteration();
+      
+      if (iteration >= this.maxIterations) {
+        console.log('Max iterations reached!');
+        break;
+      }
+      
+      // Worker phase
+      await this.runWorkerIteration();
+      
+      // Reviewer phase
+      const review = await this.runReviewerIteration();
+      
+      if (review.complete) {
+        console.log('Task completed!');
+        break;
+      }
+      
+      // Brief pause between iterations
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    
+    // Final summary
+    this.printSummary();
+  }
+
+  printSummary() {
+    const iterations = this.getCurrentIteration();
+    const progress = fs.readFileSync(this.paths.progress, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map(line => JSON.parse(line));
+    
+    console.log('\n=== Ralph Loop Summary ===');
+    console.log(`Total iterations: ${iterations}`);
+    console.log(`Total changes: ${progress.reduce((sum, p) => sum + p.changes, 0)}`);
+    console.log(`Final status: ${this.isComplete() ? 'COMPLETE' : 'INCOMPLETE'}`);
+  }
+}
+
+// CLI Interface
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  
+  if (command === 'init') {
+    const task = args[1] || 'Implement a feature';
+    const criteria = args[2] || '- Tests pass\n- Code works\n- No errors';
+    
+    const loop = new RalphLoop({ verbose: true });
+    await loop.initialize(task, criteria);
+    console.log('Ralph Loop initialized. Run with: node ralph-loop-implementation.js run');
+    
+  } else if (command === 'run') {
+    const loop = new RalphLoop({ verbose: true });
+    
+    if (!fs.existsSync(loop.paths.task)) {
+      console.error('No task found. Initialize first with: node ralph-loop-implementation.js init');
+      process.exit(1);
+    }
+    
+    await loop.run();
+    
+  } else if (command === 'status') {
+    const loop = new RalphLoop();
+    const iteration = loop.getCurrentIteration();
+    const complete = loop.isComplete();
+    const feedback = loop.getFeedback();
+    
+    console.log(`Iteration: ${iteration}`);
+    console.log(`Status: ${complete ? 'COMPLETE' : 'IN PROGRESS'}`);
+    console.log(`Last feedback: ${feedback.substring(0, 100)}`);
+    
+  } else {
+    console.log(`
+Ralph Loop Implementation
+
+Usage:
+  node ralph-loop-implementation.js init [task] [criteria]  - Initialize a new loop
+  node ralph-loop-implementation.js run                     - Run the loop
+  node ralph-loop-implementation.js status                  - Check current status
+
+Example:
+  node ralph-loop-implementation.js init "Add login feature" "- Tests pass\\n- JWT works\\n- Error handling"
+  node ralph-loop-implementation.js run
+    `);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(console.error);
+}
+
+export { RalphLoop };