oh-my-claude-sisyphus 2.5.0 → 2.6.0

package/scripts/test-notepad-integration.ts

@@ -0,0 +1,495 @@
+#!/usr/bin/env tsx
+/**
+ * Integration test for notepad auto-capture functionality
+ *
+ * Tests:
+ * - Notepad initialization
+ * - Working memory entries
+ * - Priority context
+ * - Context formatting
+ * - Entry pruning
+ * - Remember tag processing
+ */
+
+import { tmpdir } from 'os';
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+// Import notepad functions
+import {
+  initNotepad,
+  addWorkingMemoryEntry,
+  setPriorityContext,
+  getPriorityContext,
+  getWorkingMemory,
+  pruneOldEntries,
+  formatNotepadContext,
+  getNotepadStats,
+  getNotepadPath,
+  DEFAULT_CONFIG
+} from '../dist/hooks/notepad/index.js';
+
+// Import remember tag processing
+import { processOrchestratorPostTool } from '../dist/hooks/sisyphus-orchestrator/index.js';
+
+// ============================================================================
+// Test Infrastructure
+// ============================================================================
+
+interface TestResult {
+  name: string;
+  passed: boolean;
+  error?: string;
+  details?: string;
+}
+
+const results: TestResult[] = [];
+
+function test(name: string, fn: () => void | Promise<void>): void {
+  process.stdout.write(`\n🧪 ${name}... `);
+  try {
+    const result = fn();
+    if (result instanceof Promise) {
+      result
+        .then(() => {
+          results.push({ name, passed: true });
+          console.log('✅ PASS');
+        })
+        .catch((error) => {
+          results.push({
+            name,
+            passed: false,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          console.log('❌ FAIL');
+          console.error(`   Error: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    } else {
+      results.push({ name, passed: true });
+      console.log('✅ PASS');
+    }
+  } catch (error) {
+    results.push({
+      name,
+      passed: false,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    console.log('❌ FAIL');
+    console.error(`   Error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function assert(condition: boolean, message: string): void {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+function assertEquals(actual: unknown, expected: unknown, message?: string): void {
+  if (actual !== expected) {
+    throw new Error(
+      message || `Expected ${JSON.stringify(expected)} but got ${JSON.stringify(actual)}`
+    );
+  }
+}
+
+function assertContains(text: string, substring: string, message?: string): void {
+  if (!text.includes(substring)) {
+    throw new Error(
+      message || `Expected text to contain "${substring}" but it didn't.\nText: ${text}`
+    );
+  }
+}
+
+function assertNotNull<T>(value: T | null | undefined, message?: string): asserts value is T {
+  if (value === null || value === undefined) {
+    throw new Error(message || 'Expected value to not be null/undefined');
+  }
+}
+
+// ============================================================================
+// Setup and Teardown
+// ============================================================================
+
+let testDir: string;
+
+function setup(): void {
+  testDir = join(tmpdir(), `notepad-test-${Date.now()}`);
+  mkdirSync(testDir, { recursive: true });
+  console.log(`\n📁 Test directory: ${testDir}`);
+}
+
+function teardown(): void {
+  if (existsSync(testDir)) {
+    rmSync(testDir, { recursive: true, force: true });
+    console.log(`\n🧹 Cleaned up test directory`);
+  }
+}
+
+// ============================================================================
+// Test Cases
+// ============================================================================
+
+function testInitialization(): void {
+  const success = initNotepad(testDir);
+  assert(success, 'initNotepad should return true');
+
+  const notepadPath = getNotepadPath(testDir);
+  assert(existsSync(notepadPath), 'notepad.md should exist after initialization');
+
+  const content = readFileSync(notepadPath, 'utf-8');
+  assertContains(content, '# Notepad', 'should contain header');
+  assertContains(content, '## Priority Context', 'should contain Priority Context section');
+  assertContains(content, '## Working Memory', 'should contain Working Memory section');
+  assertContains(content, '## MANUAL', 'should contain MANUAL section');
+}
+
+function testWorkingMemoryEntry(): void {
+  initNotepad(testDir);
+
+  const success = addWorkingMemoryEntry(testDir, 'Test discovery: This is a test entry');
+  assert(success, 'addWorkingMemoryEntry should return true');
+
+  const workingMemory = getWorkingMemory(testDir);
+  assertNotNull(workingMemory, 'working memory should not be null');
+  assertContains(workingMemory, 'Test discovery', 'should contain the added entry');
+  assertContains(workingMemory, '###', 'should contain timestamp header');
+}
+
+function testMultipleWorkingMemoryEntries(): void {
+  const localDir = join(tmpdir(), `notepad-test-multi-${Date.now()}`);
+  mkdirSync(localDir, { recursive: true });
+
+  initNotepad(localDir);
+
+  addWorkingMemoryEntry(localDir, 'First entry');
+  addWorkingMemoryEntry(localDir, 'Second entry');
+  addWorkingMemoryEntry(localDir, 'Third entry');
+
+  const workingMemory = getWorkingMemory(localDir);
+  assertNotNull(workingMemory, 'working memory should not be null');
+  assertContains(workingMemory, 'First entry', 'should contain first entry');
+  assertContains(workingMemory, 'Second entry', 'should contain second entry');
+  assertContains(workingMemory, 'Third entry', 'should contain third entry');
+
+  // Verify entries are separated
+  const entryCount = (workingMemory.match(/###/g) || []).length;
+  assertEquals(entryCount, 3, 'should have 3 timestamp headers');
+
+  rmSync(localDir, { recursive: true, force: true });
+}
+
+function testPriorityContext(): void {
+  initNotepad(testDir);
+
+  const content = 'CRITICAL: Auth system requires JWT tokens with 15-min expiry';
+  const result = setPriorityContext(testDir, content);
+  assert(result.success, 'setPriorityContext should succeed');
+  assert(!result.warning, 'should not have warning for short content');
+
+  const retrieved = getPriorityContext(testDir);
+  assertNotNull(retrieved, 'priority context should not be null');
+  assertEquals(retrieved, content, 'retrieved content should match original');
+}
+
+function testPriorityContextOversize(): void {
+  initNotepad(testDir);
+
+  const longContent = 'x'.repeat(600); // Over 500 char limit
+  const result = setPriorityContext(testDir, longContent);
+  assert(result.success, 'setPriorityContext should still succeed');
+  assert(result.warning !== undefined, 'should have warning for oversized content');
+  assertContains(result.warning!, 'exceeds', 'warning should mention exceeding limit');
+}
+
+function testPriorityContextReplacement(): void {
+  initNotepad(testDir);
+
+  setPriorityContext(testDir, 'First priority');
+  const first = getPriorityContext(testDir);
+  assertEquals(first, 'First priority', 'should store first priority');
+
+  setPriorityContext(testDir, 'Second priority');
+  const second = getPriorityContext(testDir);
+  assertEquals(second, 'Second priority', 'should replace with second priority');
+  assertNotNull(second, 'second priority should not be null');
+  assert(!second.includes('First priority'), 'should not contain first priority');
+}
+
+function testFormatNotepadContext(): void {
+  initNotepad(testDir);
+  setPriorityContext(testDir, 'Test priority content');
+
+  const formatted = formatNotepadContext(testDir);
+  assertNotNull(formatted, 'formatted context should not be null');
+  assertContains(formatted, '<notepad-priority>', 'should have opening tag');
+  assertContains(formatted, '</notepad-priority>', 'should have closing tag');
+  assertContains(formatted, 'Test priority content', 'should contain priority content');
+  assertContains(formatted, '## Priority Context', 'should contain section header');
+}
+
+function testFormatNotepadContextEmpty(): void {
+  const localDir = join(tmpdir(), `notepad-test-empty-${Date.now()}`);
+  mkdirSync(localDir, { recursive: true });
+
+  initNotepad(localDir);
+  // Don't set any priority context
+
+  const formatted = formatNotepadContext(localDir);
+  assertEquals(formatted, null, 'should return null when no priority context');
+
+  rmSync(localDir, { recursive: true, force: true });
+}
+
+function testGetNotepadStats(): void {
+  const localDir = join(tmpdir(), `notepad-test-stats-${Date.now()}`);
+  mkdirSync(localDir, { recursive: true });
+
+  initNotepad(localDir);
+  addWorkingMemoryEntry(localDir, 'Entry 1');
+  addWorkingMemoryEntry(localDir, 'Entry 2');
+  setPriorityContext(localDir, 'Priority info');
+
+  const stats = getNotepadStats(localDir);
+  assert(stats.exists, 'notepad should exist');
+  assert(stats.totalSize > 0, 'should have non-zero total size');
+  assert(stats.prioritySize > 0, 'should have non-zero priority size');
+  assertEquals(stats.workingMemoryEntries, 2, 'should have 2 working memory entries');
+  assertNotNull(stats.oldestEntry, 'should have oldest entry timestamp');
+
+  rmSync(localDir, { recursive: true, force: true });
+}
+
+function testPruningOldEntries(): void {
+  const localDir = join(tmpdir(), `notepad-test-prune-${Date.now()}`);
+  mkdirSync(localDir, { recursive: true });
+
+  initNotepad(localDir);
+
+  // Add entries with manipulated timestamps
+  const notepadPath = getNotepadPath(localDir);
+  let content = readFileSync(notepadPath, 'utf-8');
+
+  // Manually insert entries with old dates
+  const oldDate1 = new Date();
+  oldDate1.setDate(oldDate1.getDate() - 10); // 10 days ago
+  const oldDate2 = new Date();
+  oldDate2.setDate(oldDate2.getDate() - 8); // 8 days ago
+  const recentDate = new Date();
+  recentDate.setDate(recentDate.getDate() - 2); // 2 days ago
+
+  const formatDate = (d: Date) => d.toISOString().slice(0, 16).replace('T', ' ');
+
+  const oldEntry1 = `### ${formatDate(oldDate1)}\nOld entry 1\n`;
+  const oldEntry2 = `### ${formatDate(oldDate2)}\nOld entry 2\n`;
+  const recentEntry = `### ${formatDate(recentDate)}\nRecent entry\n`;
+
+  // Insert into Working Memory section
+  content = content.replace(
+    /## Working Memory\n<!-- Session notes\. Auto-pruned after 7 days\. -->\n/,
+    `## Working Memory\n<!-- Session notes. Auto-pruned after 7 days. -->\n${oldEntry1}\n${oldEntry2}\n${recentEntry}\n`
+  );
+  writeFileSync(notepadPath, content);
+
+  // Verify 3 entries before pruning
+  const statsBefore = getNotepadStats(localDir);
+  assertEquals(statsBefore.workingMemoryEntries, 3, 'should have 3 entries before pruning');
+
+  // Prune entries older than 7 days
+  const pruneResult = pruneOldEntries(localDir, 7);
+  assertEquals(pruneResult.pruned, 2, 'should prune 2 old entries');
+  assertEquals(pruneResult.remaining, 1, 'should have 1 remaining entry');
+
+  // Verify only recent entry remains
+  const workingMemory = getWorkingMemory(localDir);
+  assertNotNull(workingMemory, 'working memory should not be null');
+  assertContains(workingMemory, 'Recent entry', 'should contain recent entry');
+  assert(!workingMemory.includes('Old entry 1'), 'should not contain old entry 1');
+  assert(!workingMemory.includes('Old entry 2'), 'should not contain old entry 2');
+
+  rmSync(localDir, { recursive: true, force: true });
+}
+
+function testRememberTagProcessing(): void {
+  initNotepad(testDir);
+
+  // Simulate agent output with <remember> tags
+  const agentOutput = `
+Here are my findings:
+
+<remember>
+Discovered that the API uses rate limiting of 100 req/min
+</remember>
+
+Some more text here.
+
+<remember priority>
+CRITICAL: Authentication tokens expire after 15 minutes
+</remember>
+
+Done!
+`;
+
+  // Process the output (simulating post-tool hook)
+  processOrchestratorPostTool(
+    {
+      toolName: 'Task',
+      toolInput: {},
+      directory: testDir
+    },
+    agentOutput
+  );
+
+  // Verify priority context was captured
+  const priority = getPriorityContext(testDir);
+  assertNotNull(priority, 'priority context should be captured');
+  assertContains(priority, 'CRITICAL', 'should contain priority tag content');
+  assertContains(priority, '15 minutes', 'should contain specific priority detail');
+
+  // Verify working memory was captured
+  const workingMemory = getWorkingMemory(testDir);
+  assertNotNull(workingMemory, 'working memory should be captured');
+  assertContains(workingMemory, 'rate limiting', 'should contain working memory content');
+  assertContains(workingMemory, '100 req/min', 'should contain specific detail');
+}
+
+function testRememberTagWithMultipleMatches(): void {
+  const localDir = join(tmpdir(), `notepad-test-multi-remember-${Date.now()}`);
+  mkdirSync(localDir, { recursive: true });
+
+  initNotepad(localDir);
+
+  const agentOutput = `
+<remember>First discovery about authentication</remember>
+<remember>Second discovery about caching</remember>
+<remember>Third discovery about error handling</remember>
+`;
+
+  processOrchestratorPostTool(
+    {
+      toolName: 'Task',
+      toolInput: {},
+      directory: localDir
+    },
+    agentOutput
+  );
+
+  const workingMemory = getWorkingMemory(localDir);
+  assertNotNull(workingMemory, 'working memory should not be null');
+  assertContains(workingMemory, 'authentication', 'should contain first discovery');
+  assertContains(workingMemory, 'caching', 'should contain second discovery');
+  assertContains(workingMemory, 'error handling', 'should contain third discovery');
+
+  // Verify 3 separate entries
+  const entryCount = (workingMemory.match(/###/g) || []).length;
+  assertEquals(entryCount, 3, 'should have 3 separate timestamped entries');
+
+  rmSync(localDir, { recursive: true, force: true });
+}
+
+function testRememberTagIgnoresNonTaskTools(): void {
+  const localDir = join(tmpdir(), `notepad-test-non-task-${Date.now()}`);
+  mkdirSync(localDir, { recursive: true });
+
+  initNotepad(localDir);
+
+  const agentOutput = `
+<remember>This should be ignored</remember>
+`;
+
+  // Process with non-Task tool
+  processOrchestratorPostTool(
+    {
+      toolName: 'Read',
+      toolInput: {},
+      directory: localDir
+    },
+    agentOutput
+  );
+
+  const workingMemory = getWorkingMemory(localDir);
+  // Should be null or empty since notepad was just initialized and no Task tool was used
+  const isEmpty = workingMemory === null || workingMemory.trim() === '';
+  assert(isEmpty, 'should not capture remember tags from non-Task tools');
+
+  rmSync(localDir, { recursive: true, force: true });
+}
+
+// ============================================================================
+// Main Test Runner
+// ============================================================================
+
+async function runTests(): Promise<void> {
+  console.log('\n═══════════════════════════════════════════════════════════');
+  console.log('  🧪 NOTEPAD INTEGRATION TEST SUITE');
+  console.log('═══════════════════════════════════════════════════════════');
+
+  setup();
+
+  try {
+    // Basic operations
+    test('Notepad initialization', testInitialization);
+    test('Add working memory entry', testWorkingMemoryEntry);
+    test('Add multiple working memory entries', testMultipleWorkingMemoryEntries);
+
+    // Priority context
+    test('Set priority context', testPriorityContext);
+    test('Priority context oversize warning', testPriorityContextOversize);
+    test('Priority context replacement', testPriorityContextReplacement);
+
+    // Formatting
+    test('Format notepad context for injection', testFormatNotepadContext);
+    test('Format empty notepad context', testFormatNotepadContextEmpty);
+
+    // Stats and info
+    test('Get notepad stats', testGetNotepadStats);
+
+    // Pruning
+    test('Prune old entries', testPruningOldEntries);
+
+    // Remember tags
+    test('Process <remember> tags', testRememberTagProcessing);
+    test('Process multiple <remember> tags', testRememberTagWithMultipleMatches);
+    test('Ignore <remember> tags from non-Task tools', testRememberTagIgnoresNonTaskTools);
+
+    // Wait a bit for any async tests
+    await new Promise(resolve => setTimeout(resolve, 100));
+
+  } finally {
+    teardown();
+  }
+
+  // Print summary
+  console.log('\n═══════════════════════════════════════════════════════════');
+  console.log('  📊 TEST SUMMARY');
+  console.log('═══════════════════════════════════════════════════════════');
+
+  const passed = results.filter(r => r.passed).length;
+  const failed = results.filter(r => !r.passed).length;
+  const total = results.length;
+
+  console.log(`\n  Total:  ${total}`);
+  console.log(`  ✅ Pass:  ${passed}`);
+  console.log(`  ❌ Fail:  ${failed}`);
+
+  if (failed > 0) {
+    console.log('\n  Failed tests:');
+    results.filter(r => !r.passed).forEach(r => {
+      console.log(`    - ${r.name}`);
+      if (r.error) {
+        console.log(`      ${r.error}`);
+      }
+    });
+  }
+
+  console.log('\n═══════════════════════════════════════════════════════════\n');
+
+  // Exit with appropriate code
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+// Run tests
+runTests().catch((error) => {
+  console.error('\n❌ Test runner failed:', error);
+  process.exit(1);
+});

package/scripts/test-remember-tags.ts

@@ -0,0 +1,121 @@
+import { tmpdir } from 'os';
+import { mkdirSync, rmSync, existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { spawn } from 'child_process';
+
+// Create test directory
+const testDir = join(tmpdir(), `remember-tag-test-${Date.now()}`);
+const sisyphusDir = join(testDir, '.sisyphus');
+mkdirSync(sisyphusDir, { recursive: true });
+
+console.log('Testing remember tag processing in post-tool-verifier.mjs\n');
+
+// Helper to run the post-tool-verifier
+async function runHook(input: object): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('node', [
+      join(import.meta.dirname, 'post-tool-verifier.mjs')
+    ], {
+      cwd: testDir
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data) => { stdout += data; });
+    proc.stderr.on('data', (data) => { stderr += data; });
+
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`Process exited with code ${code}: ${stderr}`));
+      } else {
+        resolve(stdout);
+      }
+    });
+
+    proc.stdin.write(JSON.stringify(input));
+    proc.stdin.end();
+  });
+}
+
+// Test 1: Regular remember tag
+console.log('Test 1: Regular <remember> tag');
+try {
+  const input1 = {
+    toolName: 'Task',
+    toolOutput: 'Agent completed task.\n<remember>This project uses pnpm</remember>\nDone.',
+    sessionId: 'test-session',
+    directory: testDir
+  };
+
+  await runHook(input1);
+
+  const notepadPath = join(sisyphusDir, 'notepad.md');
+  if (existsSync(notepadPath)) {
+    const content = readFileSync(notepadPath, 'utf-8');
+    if (content.includes('pnpm') && content.includes('Working Memory')) {
+      console.log('✓ PASS: Regular remember tag saved to Working Memory\n');
+    } else {
+      console.log('✗ FAIL: Remember tag not saved correctly');
+      console.log('Content:', content.slice(0, 200));
+    }
+  } else {
+    console.log('✗ FAIL: notepad.md not created\n');
+  }
+} catch (err) {
+  console.log('✗ FAIL:', (err as Error).message);
+}
+
+// Test 2: Priority remember tag
+console.log('Test 2: Priority <remember priority> tag');
+try {
+  const input2 = {
+    toolName: 'Task',
+    toolOutput: '<remember priority>API endpoint is /api/v2</remember>',
+    sessionId: 'test-session',
+    directory: testDir
+  };
+
+  await runHook(input2);
+
+  const notepadPath = join(sisyphusDir, 'notepad.md');
+  const content = readFileSync(notepadPath, 'utf-8');
+  if (content.includes('API endpoint') && content.includes('Priority Context')) {
+    console.log('✓ PASS: Priority remember tag saved to Priority Context\n');
+  } else {
+    console.log('✗ FAIL: Priority tag not saved correctly');
+    console.log('Content:', content.slice(0, 300));
+  }
+} catch (err) {
+  console.log('✗ FAIL:', (err as Error).message);
+}
+
+// Test 3: Non-Task tool should not process tags
+console.log('Test 3: Non-Task tool should not process tags');
+try {
+  // Clean up first
+  rmSync(testDir, { recursive: true });
+  mkdirSync(sisyphusDir, { recursive: true });
+
+  const input3 = {
+    toolName: 'Bash',
+    toolOutput: '<remember>Should not be saved</remember>',
+    sessionId: 'test-session',
+    directory: testDir
+  };
+
+  await runHook(input3);
+
+  const notepadPath = join(sisyphusDir, 'notepad.md');
+  if (!existsSync(notepadPath)) {
+    console.log('✓ PASS: Bash tool did not trigger remember tag processing\n');
+  } else {
+    console.log('✗ FAIL: Bash tool incorrectly triggered remember processing\n');
+  }
+} catch (err) {
+  console.log('✗ FAIL:', (err as Error).message);
+}
+
+// Clean up
+rmSync(testDir, { recursive: true });
+console.log('All tests completed.');

package/scripts/test-session-injection.ts

@@ -0,0 +1,41 @@
+import { tmpdir } from 'os';
+import { mkdirSync, rmSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+// Create test notepad
+const testDir = join(tmpdir(), `session-test-${Date.now()}`);
+const sisyphusDir = join(testDir, '.sisyphus');
+mkdirSync(sisyphusDir, { recursive: true });
+
+const notepadContent = `# Notepad
+
+## Priority Context
+Project uses pnpm not npm
+API client at src/api/client.ts
+
+## Working Memory
+
+### 2026-01-19 12:00
+Some working memory entry
+
+## MANUAL
+User notes here
+`;
+
+writeFileSync(join(sisyphusDir, 'notepad.md'), notepadContent);
+
+// Test priority context extraction (mimics session-start.mjs logic)
+const content = readFileSync(join(sisyphusDir, 'notepad.md'), 'utf-8');
+const priorityMatch = content.match(/## Priority Context\n([\s\S]*?)(?=\n## [^#]|$)/);
+const cleanContent = priorityMatch ? priorityMatch[1].replace(/<!--[\s\S]*?-->/g, '').trim() : '';
+
+// Verify extraction
+if (cleanContent.includes('pnpm') && cleanContent.includes('API client')) {
+  console.log('✓ PASS: Priority Context extracted correctly');
+} else {
+  console.log('✗ FAIL: Priority Context not extracted');
+  console.log('Got:', cleanContent);
+}
+
+// Clean up
+rmSync(testDir, { recursive: true });