@cnrai/pave 0.3.32 → 0.3.34

package/test/args-parser.test.js

@@ -0,0 +1,391 @@
+#!/usr/bin/env node
+/**
+ * Test suite for args-parser.js
+ *
+ * NOTE: This test file directly imports the real parseArgs implementation
+ * to test actual parsing behavior. The mock in run-tests.js is for other
+ * test files that need consistent args behavior.
+ */
+
+// Directly import the real parseArgs to bypass mock
+const { parseArgs } = require('../lib/args-parser');
+
+// Detect whether spawnSync actually works in this environment.
+let canSpawn = false;
+try {
+  const { spawnSync: _sp } = require('child_process');
+  if (typeof _sp === 'function') {
+    const probe = _sp(process.execPath || 'node', ['-e', 'process.stdout.write("OK")'], {
+      encoding: 'utf-8', timeout: 5000,
+    });
+    canSpawn = (probe && probe.stdout === 'OK');
+  }
+} catch (_) {}
+
+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}: expected ${expected}, got ${actual}`);
+  }
+}
+
+// Test default showTools behavior (defaults to true)
+runTest('Default showTools should be true for chat command', () => {
+  const args = parseArgs(['chat', 'hello world']);
+  assertEqual(args.command, 'chat', 'Command should be chat');
+  assertEqual(args.showTools, true, 'showTools should default to true');
+  assertEqual(args.commandArgs.join(' '), 'hello world', 'Command args should be preserved');
+});
+
+// Test --no-tools flag (explicit disable)
+runTest('--no-tools flag should set showTools to false', () => {
+  const args = parseArgs(['chat', '--no-tools', 'summarize files']);
+  assertEqual(args.command, 'chat', 'Command should be chat');
+  assertEqual(args.showTools, false, 'showTools should be false with --no-tools');
+  assertEqual(args.commandArgs.join(' '), 'summarize files', 'Command args should exclude --no-tools flag');
+});
+
+// Test --no-tools with other flags
+runTest('--no-tools should work with other chat flags', () => {
+  const args = parseArgs(['chat', '--no-tools', '--verbose', 'hello world']);
+  assertEqual(args.command, 'chat', 'Command should be chat');
+  assertEqual(args.showTools, false, 'showTools should be false');
+  assertEqual(args.verbose, true, 'Verbose should be true');
+});
+
+// Test no command (TUI mode) - default should be true
+runTest('No command should have default showTools true', () => {
+  const args = parseArgs([]);
+  assertEqual(args.showTools, true, 'showTools should default to true');
+});
+
+// Test flag parsing in chat command args
+runTest('Chat command should properly exclude --no-tools from args', () => {
+  const args = parseArgs(['chat', 'list', '--no-tools', 'all', 'files']);
+  assertEqual(args.commandArgs.join(' '), 'list all files', 'All non-flag words should be in commandArgs');
+  assertEqual(args.showTools, false, '--no-tools flag should disable showTools');
+});
+
+// Test --no-tools flag position doesn't matter
+runTest('--no-tools at end should still work', () => {
+  const args = parseArgs(['chat', 'hello', 'world', '--no-tools']);
+  assertEqual(args.showTools, false, 'showTools should be false');
+  assertEqual(args.commandArgs.join(' '), 'hello world', 'Command args should exclude --no-tools');
+});
+
+// Test non-chat commands (should have default true)
+runTest('Non-chat commands should have default showTools true', () => {
+  const args = parseArgs(['list']);
+  assertEqual(args.command, 'list', 'Command should be list');
+  assertEqual(args.showTools, true, 'showTools should default to true');
+});
+
+// ============================================
+// Agent command tests
+// The parser uses:
+//   - args.soul for --soul <path> flag
+//   - args.commandArgs for positional SOUL file (e.g., 'pave agent SOUL.md')
+//   - args.config for --config <path> flag (defaults to './.pave')
+//   - args.sleep for --sleep <duration> flag (defaults to '1m')
+// ============================================
+
+// Test agent command with no args should apply defaults
+runTest('Agent command with no args should apply defaults', () => {
+  const args = parseArgs(['agent']);
+  assertEqual(args.command, 'agent', 'Command should be agent');
+  assertEqual(args.config, './.pave', 'Config should default to ./.pave');
+  assertEqual(args.sleep, '1m', 'Sleep should default to 1m');
+  assertEqual(args.commandArgs.length, 1, 'Should have one command arg');
+  assertEqual(args.commandArgs[0], 'AGENTS.md', 'Command arg should default to AGENTS.md');
+});
+
+// Test agent command with explicit values should override defaults
+runTest('Agent command with explicit values should override defaults', () => {
+  const args = parseArgs(['agent', '--config', '/custom', '--sleep', '5m', '--soul', 'custom.md']);
+  assertEqual(args.command, 'agent', 'Command should be agent');
+  assertEqual(args.config, '/custom', 'Config should be overridden');
+  assertEqual(args.sleep, '5m', 'Sleep should be overridden');
+  assertEqual(args.soul, 'custom.md', 'Soul should be overridden');
+  assertEqual(args.commandArgs.length, 0, 'Command args should be empty when --soul is used');
+});
+
+// Test agent command with positional SOUL file should not add default
+runTest('Agent command with positional SOUL file should not add default AGENTS.md', () => {
+  const args = parseArgs(['agent', 'MY_SOUL.md']);
+  assertEqual(args.command, 'agent', 'Command should be agent');
+  assertEqual(args.config, './.pave', 'Config should still be default');
+  assertEqual(args.sleep, '1m', 'Sleep should still be default');
+  assertEqual(args.commandArgs.length, 1, 'Should have one command arg');
+  assertEqual(args.commandArgs[0], 'MY_SOUL.md', 'Command arg should be the provided file');
+});
+
+// Test agent command with partial overrides
+runTest('Agent command with partial overrides should apply remaining defaults', () => {
+  const args = parseArgs(['agent', '--config', '/tmp/.pave']);
+  assertEqual(args.command, 'agent', 'Command should be agent');
+  assertEqual(args.config, '/tmp/.pave', 'Config should be overridden');
+  assertEqual(args.sleep, '1m', 'Sleep should still be default');
+  assertEqual(args.commandArgs.length, 1, 'Should have default command arg');
+  assertEqual(args.commandArgs[0], 'AGENTS.md', 'Command arg should be default AGENTS.md');
+});
+
+// Test agent command with --soul should set soul field
+runTest('Agent command with --soul should set soul field', () => {
+  const args = parseArgs(['agent', '--soul', 'SOUL.md']);
+  assertEqual(args.command, 'agent', 'Command should be agent');
+  assertEqual(args.soul, 'SOUL.md', 'Soul should be SOUL.md');
+});
+
+// Test agent command with --sleep
+runTest('Agent command with --sleep should override default', () => {
+  const args = parseArgs(['agent', '--sleep', '5m']);
+  assertEqual(args.command, 'agent', 'Command should be agent');
+  assertEqual(args.sleep, '5m', 'Sleep should be 5m');
+});
+
+// Test agent command with --config
+runTest('Agent command with --config should override default', () => {
+  const args = parseArgs(['agent', '--config', '/home/user/.pave']);
+  assertEqual(args.command, 'agent', 'Command should be agent');
+  assertEqual(args.config, '/home/user/.pave', 'Config should match provided path');
+});
+
+// Test agent command with --verbose
+runTest('Agent command with --verbose should set verbose flag', () => {
+  const args = parseArgs(['agent', '--verbose']);
+  assertEqual(args.command, 'agent', 'Command should be agent');
+  assertEqual(args.verbose, true, 'Verbose should be true');
+});
+
+// Test agent command with --debug
+runTest('Agent command with --debug should set debug flag', () => {
+  const args = parseArgs(['agent', '--debug']);
+  assertEqual(args.command, 'agent', 'Command should be agent');
+  assertEqual(args.debug, true, 'Debug should be true');
+});
+
+// Test agent command with --help should NOT apply defaults (to avoid side effects like directory creation)
+runTest('Agent command with --help should not apply defaults', () => {
+  const args = parseArgs(['agent', '--help']);
+  assertEqual(args.command, 'agent', 'Command should be agent');
+  assertEqual(args.help, true, 'Help should be true');
+  // Defaults should NOT be applied when --help is requested to avoid side effects
+  // Note: config and sleep are initialized to null in parseArgs, not undefined
+  assertEqual(args.config, null, 'Config should be null with --help');
+  assertEqual(args.sleep, null, 'Sleep should be null with --help');
+  assertEqual(args.commandArgs.length, 0, 'Should have no command args with --help');
+});
+
+// Test agent command with --version should not apply defaults (avoid side effects)
+runTest('Agent command with --version should not apply defaults', () => {
+  const args = parseArgs(['agent', '--version']);
+  assertEqual(args.command, 'agent', 'Command should be agent');
+  assertEqual(args.version, true, 'Version should be true');
+  // Defaults should NOT be applied when --version is requested to avoid side effects
+  // Note: config and sleep are initialized to null in parseArgs, not undefined
+  assertEqual(args.config, null, 'Config should be null with --version');
+  assertEqual(args.sleep, null, 'Sleep should be null with --version');
+  assertEqual(args.commandArgs.length, 0, 'Should have no command args with --version');
+});
+
+// Test agent command with -v shorthand should not apply defaults
+runTest('Agent command with -v shorthand should not apply defaults', () => {
+  const args = parseArgs(['agent', '-v']);
+  assertEqual(args.command, 'agent', 'Command should be agent');
+  assertEqual(args.version, true, 'Version should be true');
+  // Defaults should NOT be applied when -v is requested to avoid side effects
+  // Note: config and sleep are initialized to null in parseArgs, not undefined
+  assertEqual(args.config, null, 'Config should be null with -v');
+  assertEqual(args.sleep, null, 'Sleep should be null with -v');
+  assertEqual(args.commandArgs.length, 0, 'Should have no command args with -v');
+});
+
+// Test agent command argument order doesn't matter
+runTest('Agent command args order should not matter', () => {
+  const args = parseArgs(['agent', '--sleep', '2m', '--config', '/custom']);
+  assertEqual(args.command, 'agent', 'Command should be agent');
+  assertEqual(args.config, '/custom', 'Config should be /custom');
+  assertEqual(args.sleep, '2m', 'Sleep should be 2m');
+});
+
+// Test --config without value exits with error (using subprocess)
+runTest('Agent command with --config without value should error', () => {
+  if (!canSpawn) return; // skip in sandbox
+  const { spawnSync } = require('child_process');
+  const path = require('path');
+
+  // Create a small test script that just calls parseArgs
+  const testScript = `
+    const { parseArgs } = require('./lib/args-parser');
+    parseArgs(['agent', '--config']);
+  `;
+
+  const result = spawnSync('node', ['-e', testScript], {
+    cwd: path.join(__dirname, '..'),
+    encoding: 'utf8',
+  });
+
+  assertEqual(result.status, 1, 'Should exit with status 1');
+  assertEqual(result.stderr.includes('--config requires a path argument'), true, 'Should print correct error message');
+});
+
+// Test --sleep without value exits with error (using subprocess)
+runTest('Agent command with --sleep without value should error', () => {
+  if (!canSpawn) return; // skip in sandbox
+  const { spawnSync } = require('child_process');
+  const path = require('path');
+
+  const testScript = `
+    const { parseArgs } = require('./lib/args-parser');
+    parseArgs(['agent', '--sleep']);
+  `;
+
+  const result = spawnSync('node', ['-e', testScript], {
+    cwd: path.join(__dirname, '..'),
+    encoding: 'utf8',
+  });
+
+  assertEqual(result.status, 1, 'Should exit with status 1');
+  assertEqual(result.stderr.includes('--sleep requires a value'), true, 'Should print error message');
+});
+
+// Test --soul without value exits with error (using subprocess)
+runTest('Agent command with --soul without value should error', () => {
+  if (!canSpawn) return; // skip in sandbox
+  const { spawnSync } = require('child_process');
+  const path = require('path');
+
+  const testScript = `
+    const { parseArgs } = require('./lib/args-parser');
+    parseArgs(['agent', '--soul']);
+  `;
+
+  const result = spawnSync('node', ['-e', testScript], {
+    cwd: path.join(__dirname, '..'),
+    encoding: 'utf8',
+  });
+
+  assertEqual(result.status, 1, 'Should exit with status 1');
+  assertEqual(result.stderr.includes('--soul requires a value'), true, 'Should print error message');
+});
+
+// Test --name without value exits with error (using subprocess)
+runTest('Agent command with --name without value should error', () => {
+  if (!canSpawn) return; // skip in sandbox
+  const { spawnSync } = require('child_process');
+  const path = require('path');
+
+  const testScript = `
+    const { parseArgs } = require('./lib/args-parser');
+    parseArgs(['agent', '--name']);
+  `;
+
+  const result = spawnSync('node', ['-e', testScript], {
+    cwd: path.join(__dirname, '..'),
+    encoding: 'utf8',
+  });
+
+  assertEqual(result.status, 1, 'Should exit with status 1');
+  assertEqual(result.stderr.includes('--name requires a value'), true, 'Should print error message');
+});
+
+// Test --agent without valid value exits with error (using subprocess) (#231)
+runTest('Chat command with --agent missing value should error', () => {
+  if (!canSpawn) return; // skip in sandbox
+  const { spawnSync } = require('child_process');
+  const path = require('path');
+
+  const testScript = `
+    const { parseArgs } = require('./lib/args-parser');
+    parseArgs(['chat', '--agent']);
+  `;
+
+  const result = spawnSync('node', ['-e', testScript], {
+    cwd: path.join(__dirname, '..'),
+    encoding: 'utf8',
+  });
+
+  assertEqual(result.status, 1, 'Should exit with status 1');
+  assertEqual(result.stderr.includes('--agent requires an agent name'), true, 'Should print error message');
+});
+
+// Test --agent followed by flag-like value exits with error (#231)
+runTest('Chat command with --agent followed by flag should error', () => {
+  if (!canSpawn) return; // skip in sandbox
+  const { spawnSync } = require('child_process');
+  const path = require('path');
+
+  const testScript = `
+    const { parseArgs } = require('./lib/args-parser');
+    parseArgs(['chat', '--agent', '--no-stream', 'hello']);
+  `;
+
+  const result = spawnSync('node', ['-e', testScript], {
+    cwd: path.join(__dirname, '..'),
+    encoding: 'utf8',
+  });
+
+  assertEqual(result.status, 1, 'Should exit with status 1');
+  assertEqual(result.stderr.includes('--agent requires an agent name'), true, 'Should print error message');
+});
+
+// =============================================================
+// 'pave agents' command tests (Issue #198)
+// =============================================================
+
+runTest('Agents command should set command to agents', () => {
+  const args = parseArgs(['agents']);
+  assertEqual(args.command, 'agents', 'Command should be agents');
+});
+
+runTest('Agents command with --json should set json flag', () => {
+  const args = parseArgs(['agents', '--json']);
+  assertEqual(args.command, 'agents', 'Command should be agents');
+  assertEqual(args.json, true, 'Should have json flag set');
+});
+
+// =============================================================
+// 'pave agent ps' subcommand tests (Issue #278)
+// =============================================================
+
+runTest('Agent ps subcommand should map to agents command', () => {
+  // 'pave agent ps' is mapped to 'pave agents' to avoid .pave directory creation
+  const args = parseArgs(['agent', 'ps']);
+  assertEqual(args.command, 'agents', 'Command should be agents (mapped from agent ps)');
+  assertEqual(args.agentSubcommand, null, 'agentSubcommand should be null');
+  assertEqual(args.commandArgs.length, 0, 'Should have no command args');
+});
+
+runTest('Agent ps subcommand with extra args should error', () => {
+  // Test that 'pave agent ps extra' is rejected - parseArgs calls process.exit(1)
+  // when validation fails. We mock process.exit to verify it's called with code 1.
+  const origExit = process.exit;
+  let exitCalledWith = null;
+  process.exit = (code) => { exitCalledWith = code; throw new Error('exit called'); };
+
+  try {
+    parseArgs(['agent', 'ps', 'extra']);
+  } catch (e) {
+    // Expected to throw
+  }
+
+  process.exit = origExit;
+  assertEqual(exitCalledWith, 1, 'Should call process.exit(1)');
+});
+
+console.log('\n📊 Test Summary:');
+if (process.exitCode === 1) {
+  console.log('Some tests failed. Please fix the issues above.');
+  throw new Error('args-parser tests failed');
+} else {
+  console.log('All tests passed! 🎉');
+}

package/test/auto-compaction-chat.manual-test.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+// Auto-compaction test for chat command
+// Tests that 'pave chat' automatically triggers compaction when context exceeds threshold
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Test configuration
+const TEST_CONFIG = {
+  timeout: 120000, // 2 minutes
+  tempDir: null,
+  sessionFile: null,
+  originalCwd: process.cwd(),
+};
+
+// ANSI colors for output
+const COLORS = {
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+};
+
+function log(message, color = 'reset') {
+  console.log(`${COLORS[color]}${message}${COLORS.reset}`);
+}
+
+function createTempWorkspace() {
+  const tmpDir = fs.mkdtempSync(path.join(__dirname, 'tmp-auto-compaction-'));
+  const sessionFile = path.join(tmpDir, '.pave-session.json');
+
+  TEST_CONFIG.tempDir = tmpDir;
+  TEST_CONFIG.sessionFile = sessionFile;
+
+  process.chdir(tmpDir);
+  log(`Created temp workspace: ${tmpDir}`, 'dim');
+  return { tmpDir, sessionFile };
+}
+
+function cleanup() {
+  process.chdir(TEST_CONFIG.originalCwd);
+
+  if (TEST_CONFIG.tempDir && fs.existsSync(TEST_CONFIG.tempDir)) {
+    fs.rmSync(TEST_CONFIG.tempDir, { recursive: true, force: true });
+    log(`Cleaned up: ${TEST_CONFIG.tempDir}`, 'dim');
+  }
+}
+
+function runPaveCommand(args, options = {}) {
+  const { expectError = false, timeout = 30000 } = options;
+  const pavePath = path.join(__dirname, '../index.js');
+  const cmd = `node "${pavePath}" ${args}`;
+
+  try {
+    const result = execSync(cmd, {
+      encoding: 'utf8',
+      timeout,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: TEST_CONFIG.tempDir,
+    });
+
+    if (expectError) {
+      throw new Error(`Expected command to fail but it succeeded: ${cmd}`);
+    }
+
+    return { success: true, stdout: result, stderr: '' };
+  } catch (error) {
+    if (expectError) {
+      return { success: false, stdout: '', stderr: error.message };
+    }
+    throw error;
+  }
+}
+
+async function testAutoCompaction() {
+  log('Testing auto-compaction in chat command...', 'blue');
+
+  try {
+    // Create temporary workspace
+    createTempWorkspace();
+
+    // Test 1: Create a session and fill it with many messages to exceed threshold
+    log('Step 1: Creating session with initial message...', 'yellow');
+    const result1 = runPaveCommand('chat --verbose "Hello, please introduce yourself."');
+
+    if (!result1.success) {
+      throw new Error('Failed to create initial session');
+    }
+
+    // Check session file was created
+    if (!fs.existsSync(TEST_CONFIG.sessionFile)) {
+      throw new Error('Session file was not created');
+    }
+
+    const sessionData = JSON.parse(fs.readFileSync(TEST_CONFIG.sessionFile, 'utf8'));
+    const originalSessionId = sessionData.sessionId;
+    log(`Initial session ID: ${originalSessionId}`, 'dim');
+
+    // Test 2: Send multiple large messages to trigger compaction
+    log('Step 2: Sending large messages to trigger compaction...', 'yellow');
+
+    // Create a large message that will push us over the token limit
+    const largeMessage = 'Please analyze the following text and provide detailed insights: ' +
+      'Lorem ipsum dolor sit amet, consectetur adipiscing elit. '.repeat(200) +
+      'Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. '.repeat(200) +
+      'Ut enim ad minim veniam, quis nostrud exercitation ullamco. '.repeat(200);
+
+    // Send several large messages
+    for (let i = 0; i < 3; i++) {
+      log(`  Sending message ${i + 1}/3...`, 'dim');
+      const result = runPaveCommand(`chat --verbose "${largeMessage} Message ${i + 1}"`);
+
+      if (!result.success) {
+        log(`Message ${i + 1} failed`, 'red');
+        continue;
+      }
+
+      // Check if session ID changed (indicating compaction occurred)
+      const currentData = JSON.parse(fs.readFileSync(TEST_CONFIG.sessionFile, 'utf8'));
+      if (currentData.sessionId !== originalSessionId) {
+        log(` Auto-compaction triggered! Session changed: ${originalSessionId} � ${currentData.sessionId}`, 'green');
+        return true;
+      }
+
+      // Add delay between messages
+      // await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+
+    // Test 3: Try one more very large message to force compaction
+    log('Step 3: Sending extra large message to force compaction...', 'yellow');
+    const extraLargeMessage = 'Please provide a comprehensive analysis: ' +
+      'The quick brown fox jumps over the lazy dog. '.repeat(500) +
+      'This is a test message to exceed token limits. '.repeat(500);
+
+    const _result3 = runPaveCommand(`chat --verbose "${extraLargeMessage}"`);
+
+    // Check final session state
+    const finalData = JSON.parse(fs.readFileSync(TEST_CONFIG.sessionFile, 'utf8'));
+    if (finalData.sessionId !== originalSessionId) {
+      log(` Auto-compaction triggered on large message! ${originalSessionId} � ${finalData.sessionId}`, 'green');
+      return true;
+    }
+    log(`� Compaction may not have been needed or may be disabled in test environment`, 'yellow');
+    log(`Session remained: ${finalData.sessionId}`, 'dim');
+    // This is not necessarily a failure - compaction might not be needed
+    return true;
+  } catch (error) {
+    log(` Test failed: ${error.message}`, 'red');
+    return false;
+  } finally {
+    cleanup();
+  }
+}
+
+// Test helper: Check if auto-compaction feature is working
+async function testCompactionAPI() {
+  log('Testing compaction API availability...', 'blue');
+
+  try {
+    createTempWorkspace();
+
+    // Start a session
+    const result = runPaveCommand('chat "Test message"');
+    if (!result.success) {
+      log(' Failed to create test session', 'red');
+      return false;
+    }
+
+    log(' Compaction feature appears to be available', 'green');
+    return true;
+  } catch (error) {
+    log(` Compaction API test failed: ${error.message}`, 'red');
+    return false;
+  } finally {
+    cleanup();
+  }
+}
+
+// Main test runner
+async function runTests() {
+  log('='.repeat(60), 'blue');
+  log('Auto-Compaction Chat Command Test', 'blue');
+  log('='.repeat(60), 'blue');
+
+  const tests = [
+    { name: 'Compaction API', fn: testCompactionAPI },
+    { name: 'Auto-compaction trigger', fn: testAutoCompaction },
+  ];
+
+  let passed = 0;
+  const total = tests.length;
+
+  for (const test of tests) {
+    log(`\nRunning test: ${test.name}`, 'yellow');
+    const success = await test.fn();
+    if (success) {
+      passed++;
+      log(` ${test.name} passed`, 'green');
+    } else {
+      log(` ${test.name} failed`, 'red');
+    }
+  }
+
+  log('\n' + '='.repeat(60), 'blue');
+  log(`Test Results: ${passed}/${total} passed`, passed === total ? 'green' : 'red');
+  log('='.repeat(60), 'blue');
+
+  process.exit(passed === total ? 0 : 1);
+}
+
+// Run tests if this file is executed directly
+if (require.main === module) {
+  runTests().catch((error) => {
+    log(` Test suite crashed: ${error.message}`, 'red');
+    cleanup();
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  testAutoCompaction,
+  testCompactionAPI,
+  runTests,
+};