@cnrai/pave 0.3.32 → 0.3.34

package/test/dir-migration.test.js

@@ -0,0 +1,323 @@
+/**
+ * Test directory structure migration (Issue #174)
+ *
+ * Verifies:
+ * - .pave-session.json → .pave/session.json migration
+ * - SOUL file resolution order: --soul > .pave/AGENTS.md > ./AGENTS.md
+ * - --config no longer redirects skills/marketplace
+ * - pave agent init: reserved path check, tips
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const paveIndexPath = path.join(__dirname, '..', 'index.js');
+const tuiIndexPath = path.join(__dirname, '..', '..', 'tui', 'index.js');
+
+function runDirMigrationTests() {
+  const paveSource = fs.readFileSync(paveIndexPath, 'utf8');
+  const tuiSource = fs.readFileSync(tuiIndexPath, 'utf8');
+
+  let passed = 0;
+  let failed = 0;
+
+  function test(name, fn) {
+    try {
+      fn();
+      console.log('\u2705 ' + name);
+      passed++;
+    } catch (e) {
+      console.log('\u274c ' + name);
+      console.log('  ' + e.message);
+      failed++;
+    }
+  }
+
+  function assert(cond, msg) {
+    if (!cond) throw new Error(msg || 'Assertion failed');
+  }
+
+  function assertIncludes(str, substr, msg) {
+    if (!str.includes(substr)) {
+      throw new Error((msg || 'Assertion failed') + ': expected to include ' + JSON.stringify(substr));
+    }
+  }
+
+  function assertNotIncludes(str, substr, msg) {
+    if (str.includes(substr)) {
+      throw new Error((msg || 'Assertion failed') + ': should NOT include ' + JSON.stringify(substr));
+    }
+  }
+
+  console.log('\nTesting directory structure migration (Issue #174)\n');
+  console.log('============================================================\n');
+
+  // ── resolveSessionFile helper ──
+
+  console.log('--- Session file migration ---\n');
+
+  test('pave has resolveSessionFile helper function', () => {
+    assertIncludes(paveSource, 'function resolveSessionFile(', 'Should have resolveSessionFile function');
+  });
+
+  test('resolveSessionFile reads old .pave-session.json path', () => {
+    const idx = paveSource.indexOf('function resolveSessionFile(');
+    assert(idx > -1, 'Should find resolveSessionFile');
+    const block = paveSource.substring(idx, idx + 600);
+    assertIncludes(block, '.pave-session.json', 'Should reference old session file');
+  });
+
+  test('resolveSessionFile writes new session.json path', () => {
+    const idx = paveSource.indexOf('function resolveSessionFile(');
+    assert(idx > -1, 'Should find resolveSessionFile');
+    const block = paveSource.substring(idx, idx + 600);
+    assertIncludes(block, 'session.json', 'Should reference new session.json');
+  });
+
+  test('resolveSessionFile copies old to new', () => {
+    const idx = paveSource.indexOf('function resolveSessionFile(');
+    assert(idx > -1, 'Should find resolveSessionFile');
+    const block = paveSource.substring(idx, idx + 600);
+    assertIncludes(block, 'copyFileSync', 'Should copy old file to new location');
+  });
+
+  test('resolveSessionFile deletes old file after migration', () => {
+    const idx = paveSource.indexOf('function resolveSessionFile(');
+    assert(idx > -1, 'Should find resolveSessionFile');
+    const block = paveSource.substring(idx, idx + 600);
+    assertIncludes(block, 'unlinkSync', 'Should delete old file after copy');
+  });
+
+  test('resolveSessionFile creates directory recursively', () => {
+    const idx = paveSource.indexOf('function resolveSessionFile(');
+    assert(idx > -1, 'Should find resolveSessionFile');
+    const block = paveSource.substring(idx, idx + 600);
+    assertIncludes(block, 'recursive: true', 'Should create directory recursively');
+  });
+
+  test('resolveSessionFile migration mkdir uses mode 0o700', () => {
+    const idx = paveSource.indexOf('function resolveSessionFile(');
+    assert(idx > -1, 'Should find resolveSessionFile');
+    const block = paveSource.substring(idx, idx + 800);
+    // Find the migration if-block (between existsSync checks and 'return oldPath' fallback)
+    const migrationStart = block.indexOf('copyFileSync');
+    const migrationEnd = block.indexOf('return oldPath');
+    assert(migrationStart > -1, 'Should find migration copy');
+    assert(migrationEnd > -1, 'Should find migration fallback');
+    const migrationBlock = block.substring(0, migrationEnd);
+    // The mkdirSync INSIDE the migration block should also use mode: 0o700
+    const mkdirIdx = migrationBlock.indexOf('mkdirSync');
+    assert(mkdirIdx > -1, 'Migration block should have mkdirSync');
+    const mkdirLine = migrationBlock.substring(mkdirIdx, mkdirIdx + 80);
+    assertIncludes(mkdirLine, '0o700', 'Migration mkdirSync should use mode 0o700');
+  });
+
+  test('chat command uses resolveSessionFile', () => {
+    const idx = paveSource.indexOf('async function handleChatCommand');
+    assert(idx > -1, 'Should find handleChatCommand');
+    const block = paveSource.substring(idx, idx + 30000);
+    assertIncludes(block, 'resolveSessionFile(configDir)', 'Chat should use resolveSessionFile');
+  });
+
+  test('agent command uses resolveSessionFile', () => {
+    const idx = paveSource.indexOf('async function handleAgentCommand');
+    assert(idx > -1, 'Should find handleAgentCommand');
+    const block = paveSource.substring(idx, idx + 30000);
+    assertIncludes(block, 'resolveSessionFile(configDir)', 'Agent should use resolveSessionFile');
+  });
+
+  test('history command uses resolveSessionFile', () => {
+    // pave history should use the new path
+    const idx = paveSource.indexOf('async function handleHistoryCommand');
+    assert(idx > -1, 'Should find handleHistoryCommand');
+    const block = paveSource.substring(idx, idx + 30000);
+    assertIncludes(block, 'resolveSessionFile(configDir)', 'History should use resolveSessionFile(configDir)');
+  });
+
+  test('resolveSessionFile creates directory on fresh projects', () => {
+    const idx = paveSource.indexOf('function resolveSessionFile(');
+    assert(idx > -1, 'Should find resolveSessionFile');
+    const block = paveSource.substring(idx, idx + 800);
+    // Should have a mkdirSync call OUTSIDE the migration if-block
+    const migrationEnd = block.indexOf('return oldPath');
+    assert(migrationEnd > -1, 'Should find migration fallback');
+    const afterMigration = block.substring(migrationEnd);
+    assertIncludes(afterMigration, 'mkdirSync', 'Should ensure directory exists on fresh projects');
+    assertIncludes(afterMigration, 'recursive: true', 'Should create recursively');
+  });
+
+  // ── TUI session file migration ──
+
+  console.log('\n--- TUI session file ---\n');
+
+  test('TUI migrates .pave-session.json to .pave/session.json', () => {
+    assertIncludes(tuiSource, '.pave-session.json', 'TUI should reference old path for migration');
+    assertIncludes(tuiSource, "session.json", 'TUI should reference new session.json');
+  });
+
+  test('TUI session migration is inline IIFE', () => {
+    // TUI does inline migration since it can't import pave's helper
+    assertIncludes(tuiSource, 'issue #174', 'Should reference issue #174');
+  });
+
+  // ── SOUL file resolution ──
+
+  console.log('\n--- SOUL file resolution ---\n');
+
+  test('soul resolution checks .pave/AGENTS.md', () => {
+    const idx = paveSource.indexOf('resolvedSoulPath');
+    assert(idx > -1, 'Should find resolvedSoulPath');
+    const block = paveSource.substring(idx, idx + 500);
+    assertIncludes(block, "AGENTS.md", 'Should reference AGENTS.md in config dir');
+    assertIncludes(block, 'configDir', 'Should use configDir for .pave/AGENTS.md lookup');
+  });
+
+  test('explicit --soul flag has highest priority', () => {
+    const idx = paveSource.indexOf('resolvedSoulPath');
+    assert(idx > -1, 'Should find resolvedSoulPath');
+    const block = paveSource.substring(idx, idx + 500);
+    // soul (explicit flag) should be checked first
+    const soulIdx = block.indexOf('if (soul)');
+    const paveIdx = block.indexOf('paveAgents');
+    assert(soulIdx > -1, 'Should check explicit soul flag');
+    assert(paveIdx > -1, 'Should check paveAgents path');
+    assert(soulIdx < paveIdx, 'Explicit --soul should have higher priority than .pave/AGENTS.md');
+  });
+
+  test('.pave/AGENTS.md checked before ./AGENTS.md', () => {
+    const idx = paveSource.indexOf('resolvedSoulPath');
+    assert(idx > -1, 'Should find resolvedSoulPath');
+    const block = paveSource.substring(idx, idx + 800);
+    assertIncludes(block, 'fs.existsSync(paveAgents)', 'Should check if .pave/AGENTS.md exists');
+  });
+
+  test('custom positional SOUL path not overridden by .pave/AGENTS.md', () => {
+    const idx = paveSource.indexOf('resolvedSoulPath');
+    assert(idx > -1, 'Should find resolvedSoulPath');
+    const block = paveSource.substring(idx, idx + 800);
+    assertIncludes(block, 'usingDefaultAgents', 'Should check if using default AGENTS.md');
+    // When using custom path (not AGENTS.md), should use rootAgents directly
+    assertIncludes(block, 'resolvedSoulPath = rootAgents', 'Custom positional path should be used as-is');
+  });
+
+  test('TUI mkdir uses mode 0o700 for .pave directory', () => {
+    const idx = tuiSource.indexOf('Ensure directory exists even on fresh');
+    assert(idx > -1, 'Should find fresh project mkdir');
+    const block = tuiSource.substring(idx, idx + 200);
+    assertIncludes(block, 'mode: 0o700', 'Should use restrictive permissions on .pave/');
+  });
+
+  // ── --config behavior ──
+
+  console.log('\n--- --config behavior ---\n');
+
+  test('--config does not redirect skillManager', () => {
+    // Should NOT have skillManager.setPaveHome(configPath)
+    assertNotIncludes(paveSource, 'skillManager.setPaveHome(configPath)',
+      'Skills should always use ~/.pave/, not --config path');
+  });
+
+  test('--config does not redirect marketplace', () => {
+    assertNotIncludes(paveSource, 'marketplace.setPaveHome(configPath)',
+      'Marketplace should always use ~/.pave/, not --config path');
+  });
+
+  test('--config still sets Permission config dir', () => {
+    assertIncludes(paveSource, 'Permission.setConfigDir(configPath)',
+      'Permissions should follow --config');
+  });
+
+  // ── pave agent init ──
+
+  console.log('\n--- pave agent init ---\n');
+
+  test('agent init rejects reserved paths using path.relative', () => {
+    const idx = paveSource.indexOf('function handleAgentInit');
+    assert(idx > -1, 'Should find handleAgentInit');
+    const block = paveSource.substring(idx, idx + 5000);
+    assertIncludes(block, 'reservedDirs', 'Should check reserved directories');
+    assertIncludes(block, 'path.relative', 'Should use path.relative for boundary check');
+    assertIncludes(block, 'homedir()', 'Should use homedir() for cross-platform home directory');
+  });
+
+  test('agent init reserved-path error uses resolved paveHome path', () => {
+    const idx = paveSource.indexOf('function handleAgentInit');
+    assert(idx > -1, 'Should find handleAgentInit');
+    const block = paveSource.substring(idx, idx + 5000);
+    // Error message should use paveHome variable (cross-platform), not hardcoded ~/.pave/
+    assertIncludes(block, 'paveHome', 'Reserved-path error should use resolved paveHome');
+    assert(!block.includes("~/.pave/"), 'Should NOT hardcode ~/.pave/ in error message (not cross-platform)');
+  });
+
+  test('agent init shows AGENTS.md tip with configPath', () => {
+    const idx = paveSource.indexOf('function handleAgentInit');
+    assert(idx > -1, 'Should find handleAgentInit');
+    const block = paveSource.substring(idx, idx + 5000);
+    assertIncludes(block, 'AGENTS.md', 'Should show AGENTS.md tip');
+    assertIncludes(block, 'configRelPath', 'Should use relative path for tips');
+  });
+
+  test('agent init shows .gitignore tip with configPath', () => {
+    const idx = paveSource.indexOf('function handleAgentInit');
+    assert(idx > -1, 'Should find handleAgentInit');
+    const block = paveSource.substring(idx, idx + 5000);
+    assertIncludes(block, '.gitignore', 'Should show .gitignore tip');
+    assertIncludes(block, 'session.json', 'Should mention session.json');
+    assertIncludes(block, 'configRelPath', 'Should use relative path for session tip');
+  });
+
+  // ── No stale references ──
+
+  console.log('\n--- No stale references ---\n');
+
+  test('--config threads SESSION_FILE env var to TUI before require', () => {
+    // runTUI should set process.env.SESSION_FILE from configPath before loading TUI
+    let tuiRequireIdx = paveSource.indexOf("require(\"../tui/index.js\")");
+    if (tuiRequireIdx === -1) tuiRequireIdx = paveSource.indexOf("require('../tui/index.js')");
+    assert(tuiRequireIdx > -1, 'Should find TUI require');
+    // SESSION_FILE env var should be set BEFORE the TUI require
+    const beforeTuiRequire = paveSource.substring(0, tuiRequireIdx);
+    assert(beforeTuiRequire.includes('process.env.SESSION_FILE') && beforeTuiRequire.includes('configPath'),
+      'Should set process.env.SESSION_FILE from configPath before requiring TUI');
+  });
+
+  test('no direct .pave-session.json path construction outside migration', () => {
+    // Count occurrences - should only be in resolveSessionFile helper + comments
+    const lines = paveSource.split('\n');
+    let directConstructions = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.includes('.pave-session.json') &&
+          !line.includes('Migrat') &&
+          !line.includes('migrat') &&
+          !line.includes('oldPath') &&
+          !line.includes('//') &&
+          !line.includes('*')) {
+        directConstructions++;
+      }
+    }
+    assert(directConstructions === 0,
+      'Should not directly construct .pave-session.json path outside migration (found ' + directConstructions + ')');
+  });
+
+  // ============================================================
+
+  console.log('\n============================================================');
+  console.log('Results: ' + passed + ' passed, ' + failed + ' failed, ' + (passed + failed) + ' total');
+  console.log('============================================================\n');
+
+  if (failed > 0) {
+    if (require.main === module) {
+      process.exit(1);
+    } else {
+      throw new Error(failed + ' test(s) failed in dir-migration');
+    }
+  }
+
+  return { passed, failed, total: passed + failed };
+}
+
+// Auto-execute tests on load
+runDirMigrationTests();
+
+module.exports = { runDirMigrationTests };

package/test/duration.test.js

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+/**
+ * Automated tests for duration.js - parseSleepDuration and formatDuration
+ * This file runs under `npm test` via test/run-tests.js
+ */
+
+const { parseSleepDuration, formatDuration, MAX_SETTIMEOUT_MS, MIN_SLEEP_MS } = require('../lib/duration');
+
+function runTest(name, testFn) {
+  try {
+    testFn();
+    console.log(`✅ ${name}`);
+  } catch (error) {
+    console.log(`❌ ${name}: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+function assertEqual(actual, expected, message) {
+  if (actual !== expected) {
+    throw new Error(`${message || 'Assertion'}: expected ${expected}, got ${actual}`);
+  }
+}
+
+function assertThrows(fn, expectedMessage) {
+  try {
+    fn();
+    throw new Error(`Expected to throw but did not`);
+  } catch (error) {
+    if (expectedMessage && !error.message.includes(expectedMessage)) {
+      throw new Error(`Expected error containing "${expectedMessage}", got "${error.message}"`);
+    }
+  }
+}
+
+function assertLessThanOrEqual(actual, expected, message) {
+  if (actual > expected) {
+    throw new Error(`${message || 'Assertion'}: expected ${actual} <= ${expected}`);
+  }
+}
+
+// ============================================================================
+// parseSleepDuration Tests - Default Value
+// ============================================================================
+
+runTest('parseSleepDuration: null returns 5 minutes', () => {
+  assertEqual(parseSleepDuration(null), 5 * 60 * 1000);
+});
+
+runTest('parseSleepDuration: undefined returns 5 minutes', () => {
+  assertEqual(parseSleepDuration(undefined), 5 * 60 * 1000);
+});
+
+// ============================================================================
+// parseSleepDuration Tests - Seconds
+// ============================================================================
+
+runTest('parseSleepDuration: 5s = 5000ms', () => {
+  assertEqual(parseSleepDuration('5s'), 5000);
+});
+
+runTest('parseSleepDuration: 30sec = 30000ms', () => {
+  assertEqual(parseSleepDuration('30sec'), 30000);
+});
+
+// ============================================================================
+// parseSleepDuration Tests - Minutes
+// ============================================================================
+
+runTest('parseSleepDuration: 5m = 5 minutes', () => {
+  assertEqual(parseSleepDuration('5m'), 5 * 60 * 1000);
+});
+
+runTest('parseSleepDuration: 30min = 30 minutes', () => {
+  assertEqual(parseSleepDuration('30min'), 30 * 60 * 1000);
+});
+
+// ============================================================================
+// parseSleepDuration Tests - Hours
+// ============================================================================
+
+runTest('parseSleepDuration: 1h = 1 hour', () => {
+  assertEqual(parseSleepDuration('1h'), 60 * 60 * 1000);
+});
+
+runTest('parseSleepDuration: 2hr = 2 hours', () => {
+  assertEqual(parseSleepDuration('2hr'), 2 * 60 * 60 * 1000);
+});
+
+runTest('parseSleepDuration: 3hour = 3 hours', () => {
+  assertEqual(parseSleepDuration('3hour'), 3 * 60 * 60 * 1000);
+});
+
+// ============================================================================
+// parseSleepDuration Tests - Days
+// ============================================================================
+
+runTest('parseSleepDuration: 1d = 1 day', () => {
+  assertEqual(parseSleepDuration('1d'), 24 * 60 * 60 * 1000);
+});
+
+runTest('parseSleepDuration: 2day = 2 days', () => {
+  assertEqual(parseSleepDuration('2day'), 2 * 24 * 60 * 60 * 1000);
+});
+
+// ============================================================================
+// parseSleepDuration Tests - Fractional Values
+// ============================================================================
+
+runTest('parseSleepDuration: 1.5m = 1.5 minutes', () => {
+  assertEqual(parseSleepDuration('1.5m'), 1.5 * 60 * 1000);
+});
+
+runTest('parseSleepDuration: 0.5h = 30 minutes', () => {
+  assertEqual(parseSleepDuration('0.5h'), 0.5 * 60 * 60 * 1000);
+});
+
+// ============================================================================
+// parseSleepDuration Tests - Default Unit (minutes)
+// ============================================================================
+
+runTest('parseSleepDuration: 10 (no unit) = 10 minutes', () => {
+  assertEqual(parseSleepDuration('10'), 10 * 60 * 1000);
+});
+
+// ============================================================================
+// parseSleepDuration Tests - Validation Errors
+// ============================================================================
+
+runTest('parseSleepDuration: 0s throws error', () => {
+  assertThrows(() => parseSleepDuration('0s'), 'must be greater than 0');
+});
+
+runTest('parseSleepDuration: -5m throws error', () => {
+  assertThrows(() => parseSleepDuration('-5m'), 'Invalid sleep duration');
+});
+
+runTest('parseSleepDuration: abc throws error', () => {
+  assertThrows(() => parseSleepDuration('abc'), 'Invalid sleep duration');
+});
+
+runTest('parseSleepDuration: 0.5s throws (< 1 second)', () => {
+  assertThrows(() => parseSleepDuration('0.5s'), 'at least 1 second');
+});
+
+runTest('parseSleepDuration: 30d throws (exceeds max)', () => {
+  assertThrows(() => parseSleepDuration('30d'), 'exceeds maximum');
+});
+
+runTest('parseSleepDuration: 24d is within limit', () => {
+  const result = parseSleepDuration('24d');
+  assertLessThanOrEqual(result, MAX_SETTIMEOUT_MS);
+});
+
+// ============================================================================
+// formatDuration Tests - Milliseconds
+// ============================================================================
+
+runTest('formatDuration: 500ms', () => {
+  assertEqual(formatDuration(500), '500ms');
+});
+
+// ============================================================================
+// formatDuration Tests - Seconds
+// ============================================================================
+
+runTest('formatDuration: 5000ms = 5s', () => {
+  assertEqual(formatDuration(5000), '5s');
+});
+
+runTest('formatDuration: 30000ms = 30s', () => {
+  assertEqual(formatDuration(30000), '30s');
+});
+
+runTest('formatDuration: 1500ms = 1.5s', () => {
+  assertEqual(formatDuration(1500), '1.5s');
+});
+
+// ============================================================================
+// formatDuration Tests - Minutes
+// ============================================================================
+
+runTest('formatDuration: 60000ms = 1m', () => {
+  assertEqual(formatDuration(60000), '1m');
+});
+
+runTest('formatDuration: 300000ms = 5m', () => {
+  assertEqual(formatDuration(300000), '5m');
+});
+
+runTest('formatDuration: 90000ms = 1.5m', () => {
+  assertEqual(formatDuration(90000), '1.5m');
+});
+
+// ============================================================================
+// formatDuration Tests - Hours
+// ============================================================================
+
+runTest('formatDuration: 3600000ms = 1.0h', () => {
+  assertEqual(formatDuration(3600000), '1.0h');
+});
+
+runTest('formatDuration: 7200000ms = 2.0h', () => {
+  assertEqual(formatDuration(7200000), '2.0h');
+});
+
+// ============================================================================
+// formatDuration Tests - Days
+// ============================================================================
+
+runTest('formatDuration: 86400000ms = 1.0d', () => {
+  assertEqual(formatDuration(86400000), '1.0d');
+});
+
+runTest('formatDuration: 172800000ms = 2.0d', () => {
+  assertEqual(formatDuration(172800000), '2.0d');
+});
+
+// ============================================================================
+// Constants Tests
+// ============================================================================
+
+runTest('MAX_SETTIMEOUT_MS is 2147483647', () => {
+  assertEqual(MAX_SETTIMEOUT_MS, 2147483647);
+});
+
+runTest('MIN_SLEEP_MS is 1000', () => {
+  assertEqual(MIN_SLEEP_MS, 1000);
+});