@cnrai/pave 0.3.35 → 0.3.51

package/test/soul-reread.test.js

@@ -1,281 +0,0 @@
-/**
- * Tests for SOUL file re-reading behavior in agent mode
- *
- * Verifies that the SOUL file is re-read on each iteration so that
- * runtime changes to the file are picked up without restarting the agent.
- *
- * Issue: https://github.com/cnrai/openpave/issues/89
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// Import the production validateSoulFile helper directly (no fallback).
-// A require failure here means the export path is broken and should fail the test.
-const { validateSoulFile } = require('../lib/soul');
-
-// Helper to create a temporary SOUL file
-function createTempSoulFile(content) {
-  const tmpDir = os.tmpdir();
-  const soulPath = path.join(tmpDir, `test-soul-${Date.now()}-${Math.random().toString(36).slice(2)}.md`);
-  fs.writeFileSync(soulPath, content, 'utf8');
-  return soulPath;
-}
-
-// Helper to clean up temp files
-function removeTempFile(filePath) {
-  try {
-    if (fs.existsSync(filePath)) {
-      fs.unlinkSync(filePath);
-    }
-  } catch (e) {
-    // Ignore cleanup errors
-  }
-}
-
-/**
- * Simulate the per-iteration SOUL read + message decision logic from the agent.
- * This mirrors the code inside the while(running) loop:
- *   1. Re-read SOUL file
- *   2. If !soulSent -> message = soulContent (sendingSoul = true)
- *   3. Else -> message = 'keep going'
- *   4. After successful send, soulSent = true (only on success)
- *
- * @param {string} soulPath - Path to the SOUL file
- * @param {object} state - Mutable state with { soulSent: boolean }
- * @param {object} [opts] - Options
- * @param {boolean} [opts.sendSuccess=true] - Simulate whether the send succeeds
- * @returns {{ message, soulSent, error, sendingSoul, readContent }}
- */
-function simulateIteration(soulPath, state, opts) {
-  const sendSuccess = (opts && opts.sendSuccess !== undefined) ? opts.sendSuccess : true;
-
-  let soulContent;
-  try {
-    soulContent = fs.readFileSync(soulPath, 'utf8');
-  } catch (err) {
-    return { message: null, soulSent: state.soulSent, error: err, readContent: null };
-  }
-
-  const sendingSoul = !state.soulSent;
-  let message;
-  if (sendingSoul) {
-    message = soulContent;
-  } else {
-    message = 'keep going';
-  }
-
-  // Only mark soulSent after a successful send (mirrors production code)
-  if (sendSuccess && sendingSoul) {
-    state.soulSent = true;
-  }
-
-  return { message, soulSent: state.soulSent, error: null, sendingSoul, readContent: soulContent };
-}
-
-describe('SOUL file re-reading (issue #89)', () => {
-  test('SOUL content is sent on first iteration of a new session', () => {
-    const soulPath = createTempSoulFile('# My SOUL\nDo important work');
-    try {
-      const state = { soulSent: false }; // new session
-      const result = simulateIteration(soulPath, state);
-
-      expect(result.error).toBeNull();
-      expect(result.message).toBe('# My SOUL\nDo important work');
-      expect(result.soulSent).toBe(true);
-      expect(result.sendingSoul).toBe(true);
-    } finally {
-      removeTempFile(soulPath);
-    }
-  });
-
-  test('subsequent iterations send "keep going" after SOUL has been sent', () => {
-    const soulPath = createTempSoulFile('# SOUL v1');
-    try {
-      const state = { soulSent: true }; // already sent
-      const result = simulateIteration(soulPath, state);
-
-      expect(result.error).toBeNull();
-      expect(result.message).toBe('keep going');
-      expect(result.sendingSoul).toBe(false);
-    } finally {
-      removeTempFile(soulPath);
-    }
-  });
-
-  test('resumed sessions skip SOUL and send "keep going"', () => {
-    const soulPath = createTempSoulFile('# SOUL');
-    try {
-      // Resumed sessions initialize soulSent = true (matching: let soulSent = !isNewSession)
-      const state = { soulSent: true };
-      const result = simulateIteration(soulPath, state);
-
-      expect(result.message).toBe('keep going');
-      expect(result.sendingSoul).toBe(false);
-    } finally {
-      removeTempFile(soulPath);
-    }
-  });
-
-  test('SOUL file changes are picked up on re-read between iterations', () => {
-    const soulPath = createTempSoulFile('# SOUL v1\nDo task A');
-    try {
-      const state = { soulSent: false };
-
-      // First iteration sends SOUL v1
-      const r1 = simulateIteration(soulPath, state);
-      expect(r1.message).toContain('SOUL v1');
-      expect(r1.readContent).toContain('SOUL v1');
-
-      // User edits SOUL file between iterations
-      fs.writeFileSync(soulPath, '# SOUL v2\nDo task B instead', 'utf8');
-
-      // Second iteration re-reads the file and gets v2 content
-      const r2 = simulateIteration(soulPath, state);
-      expect(r2.message).toBe('keep going');
-      // Assert the updated content was actually read (not cached from v1)
-      expect(r2.readContent).toContain('SOUL v2');
-      expect(r2.readContent).toContain('Do task B instead');
-      expect(r2.readContent).not.toContain('SOUL v1');
-    } finally {
-      removeTempFile(soulPath);
-    }
-  });
-
-  test('transient read failure does NOT permanently skip SOUL delivery', () => {
-    // This is the key bug that was fixed: if the SOUL file is temporarily
-    // unreadable on the first attempt, soulSent stays false so the next
-    // successful iteration will still send SOUL content.
-    const soulPath = createTempSoulFile('# Important SOUL');
-    try {
-      const state = { soulSent: false };
-
-      // Simulate transient failure: delete file temporarily
-      const originalContent = fs.readFileSync(soulPath, 'utf8');
-      fs.unlinkSync(soulPath);
-
-      // Iteration fails to read SOUL
-      const r1 = simulateIteration(soulPath, state);
-      expect(r1.error).not.toBeNull();
-      expect(r1.soulSent).toBe(false); // Still false! Not permanently skipped
-
-      // File comes back (user recreates it)
-      fs.writeFileSync(soulPath, originalContent, 'utf8');
-
-      // Next iteration successfully sends SOUL
-      const r2 = simulateIteration(soulPath, state);
-      expect(r2.error).toBeNull();
-      expect(r2.message).toBe('# Important SOUL');
-      expect(r2.soulSent).toBe(true);
-    } finally {
-      removeTempFile(soulPath);
-    }
-  });
-
-  test('multiple transient failures followed by recovery still sends SOUL', () => {
-    const soulPath = createTempSoulFile('# My Instructions');
-    try {
-      const state = { soulSent: false };
-      const content = fs.readFileSync(soulPath, 'utf8');
-      fs.unlinkSync(soulPath);
-
-      // Fail 3 times
-      for (let i = 0; i < 3; i++) {
-        const r = simulateIteration(soulPath, state);
-        expect(r.error).not.toBeNull();
-        expect(r.soulSent).toBe(false);
-      }
-
-      // Recover
-      fs.writeFileSync(soulPath, content, 'utf8');
-      const r = simulateIteration(soulPath, state);
-      expect(r.error).toBeNull();
-      expect(r.message).toBe('# My Instructions');
-      expect(r.soulSent).toBe(true);
-    } finally {
-      removeTempFile(soulPath);
-    }
-  });
-
-  test('compaction guard uses boolean flag, not message string comparison', () => {
-    // Verify that the iteration logic returns a sendingSoul boolean
-    // that can be used for compaction guard instead of string comparison
-    const soulPath = createTempSoulFile('# SOUL');
-    try {
-      const state = { soulSent: false };
-      const r = simulateIteration(soulPath, state);
-
-      // sendingSoul is a boolean derived from control flow
-      expect(typeof r.sendingSoul).toBe('boolean');
-      expect(r.sendingSoul).toBe(true); // first iteration sends SOUL
-
-      // After SOUL sent, sendingSoul becomes false
-      const r2 = simulateIteration(soulPath, state);
-      expect(r2.sendingSoul).toBe(false);
-    } finally {
-      removeTempFile(soulPath);
-    }
-  });
-
-  test('soulSent only flips after a successful send, not before', () => {
-    // If the send fails (HTTP error, session busy), soulSent should remain false
-    // so the next iteration retries sending SOUL content
-    const soulPath = createTempSoulFile('# Critical SOUL');
-    try {
-      const state = { soulSent: false };
-
-      // Iteration 1: read succeeds but send fails
-      const r1 = simulateIteration(soulPath, state, { sendSuccess: false });
-      expect(r1.error).toBeNull(); // File was read OK
-      expect(r1.message).toBe('# Critical SOUL'); // SOUL content was prepared
-      expect(r1.sendingSoul).toBe(true); // Was attempting SOUL delivery
-      expect(r1.soulSent).toBe(false); // But send failed, so NOT marked as sent
-
-      // Iteration 2: retry also fails
-      const r2 = simulateIteration(soulPath, state, { sendSuccess: false });
-      expect(r2.message).toBe('# Critical SOUL'); // Still trying to send SOUL
-      expect(r2.soulSent).toBe(false); // Still not sent
-
-      // Iteration 3: send succeeds
-      const r3 = simulateIteration(soulPath, state, { sendSuccess: true });
-      expect(r3.message).toBe('# Critical SOUL');
-      expect(r3.soulSent).toBe(true); // NOW marked as sent
-
-      // Iteration 4: sends "keep going"
-      const r4 = simulateIteration(soulPath, state);
-      expect(r4.message).toBe('keep going');
-      expect(r4.sendingSoul).toBe(false);
-    } finally {
-      removeTempFile(soulPath);
-    }
-  });
-});
-
-describe('validateSoulFile (lib/soul.js)', () => {
-  test('accepts a valid readable file', () => {
-    const soulPath = createTempSoulFile('# Valid SOUL');
-    try {
-      const result = validateSoulFile(soulPath);
-      expect(result.valid).toBe(true);
-      expect(result.error).toBeUndefined();
-    } finally {
-      removeTempFile(soulPath);
-    }
-  });
-
-  test('rejects a non-existent file with ENOENT in error', () => {
-    const fakePath = path.join(os.tmpdir(), `nonexistent-soul-${Date.now()}.md`);
-    const result = validateSoulFile(fakePath);
-    expect(result.valid).toBe(false);
-    expect(result.error).toContain('ENOENT');
-    expect(result.error).toContain(fakePath);
-  });
-
-  test('rejects a directory', () => {
-    const result = validateSoulFile(os.tmpdir());
-    expect(result.valid).toBe(false);
-    expect(result.error).toContain('not a regular file');
-    expect(result.error).toContain(os.tmpdir());
-  });
-});