@cnrai/pave 0.3.32 → 0.3.34

package/test/agent-rm.test.js

@@ -0,0 +1,442 @@
+#!/usr/bin/env node
+/**
+ * Tests for 'pave agent rm' command (Issue #289)
+ *
+ * Verifies:
+ * - args-parser recognizes 'rm' as agent subcommand
+ * - Positional and --name flag parsing, --force parsing
+ * - handleAgentRm function exists and is dispatched
+ * - Liveness check uses isAgentAlive (not state string comparison)
+ * - Force path delegates to registry.stopAgent() (not manual kill)
+ * - Re-checks liveness after stop before removal
+ * - removeAgent uses recursive deletion (fs.rmSync)
+ * - removeAgent only ignores ENOENT, throws on other errors
+ * - removeAgent returns result object { removed, error }
+ * - Help text includes rm subcommand
+ *
+ * Run with: node test/agent-rm.test.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+let passed = 0;
+let failed = 0;
+
+function runTest(name, fn) {
+  try {
+    fn();
+    console.log('\u2705 ' + name);
+    passed++;
+  } catch (e) {
+    console.log('\u274C ' + name + ': ' + e.message);
+    failed++;
+  }
+}
+
+// ============================================================
+// Load source files for inspection
+// ============================================================
+
+const paveSource = fs.readFileSync(
+  path.join(__dirname, '..', 'index.js'), 'utf8');
+const argsParserSource = fs.readFileSync(
+  path.join(__dirname, '..', 'lib', 'args-parser.js'), 'utf8');
+const registrySource = fs.readFileSync(
+  path.join(__dirname, '..', 'lib', 'agent-registry.js'), 'utf8');
+
+// Helper: get handleAgentRm function body (use function boundary, not arbitrary window)
+function getRmFuncSection() {
+  const idx = paveSource.indexOf('async function handleAgentRm(');
+  assert(idx !== -1, 'handleAgentRm function should exist');
+  // Find the closing brace at function scope (line starts with })
+  let endIdx = paveSource.indexOf('\n}\n', idx);
+  if (endIdx === -1) endIdx = idx + 3500; // fallback
+  return paveSource.substring(idx, endIdx + 2);
+}
+
+// Helper: get removeAgent function body
+function getRemoveAgentBody() {
+  const idx = registrySource.indexOf('function removeAgent(');
+  assert(idx !== -1, 'removeAgent function should exist');
+  const endIdx = registrySource.indexOf('\n}', idx);
+  return registrySource.substring(idx, endIdx + 2);
+}
+
+// ============================================================
+// 1. args-parser: rm subcommand recognition
+// ============================================================
+
+runTest('args-parser: recognizes rm as agentSubcommand', () => {
+  assert(argsParserSource.indexOf("a === 'rm'") !== -1,
+    'rm should be in the subcommand keyword check');
+});
+
+runTest('args-parser: rm inline comment includes rm in keyword list', () => {
+  const commentIdx = argsParserSource.indexOf('subcommand keyword');
+  assert(commentIdx !== -1, 'should have subcommand keyword comment');
+  const commentSection = argsParserSource.substring(commentIdx, commentIdx + 200);
+  assert(commentSection.indexOf('rm') !== -1,
+    'inline comment should list rm as recognized subcommand');
+});
+
+runTest('args-parser: validation comment includes rm', () => {
+  const valIdx = argsParserSource.indexOf('For subcommands (');
+  assert(valIdx !== -1, 'should have validation comment');
+  const valSection = argsParserSource.substring(valIdx, valIdx + 100);
+  assert(valSection.indexOf('rm') !== -1,
+    'validation comment should include rm');
+});
+
+runTest('args-parser: rm accepts at most one agent name', () => {
+  assert(argsParserSource.indexOf("agentSubcommand === 'rm'") !== -1,
+    'rm should be in the at-most-one-name validation block');
+});
+
+runTest('args-parser: functional - parse "pave agent rm abc"', () => {
+  const parseArgs = require(path.join(__dirname, '..', 'lib', 'args-parser.js')).parseArgs;
+  const result = parseArgs(['agent', 'rm', 'abc']);
+  assert(result.command === 'agent', 'command should be agent');
+  assert(result.agentSubcommand === 'rm', 'agentSubcommand should be rm');
+  assert(result.commandArgs[0] === 'abc', 'first commandArg should be abc');
+});
+
+runTest('args-parser: functional - parse "pave agent rm --force abc"', () => {
+  const parseArgs = require(path.join(__dirname, '..', 'lib', 'args-parser.js')).parseArgs;
+  const result = parseArgs(['agent', 'rm', '--force', 'abc']);
+  assert(result.command === 'agent', 'command should be agent');
+  assert(result.agentSubcommand === 'rm', 'agentSubcommand should be rm');
+  assert(result.force === true, 'force should be true');
+  assert(result.commandArgs[0] === 'abc', 'first commandArg should be abc');
+});
+
+runTest('args-parser: functional - parse "pave agent rm --name abc"', () => {
+  const parseArgs = require(path.join(__dirname, '..', 'lib', 'args-parser.js')).parseArgs;
+  const result = parseArgs(['agent', 'rm', '--name', 'abc']);
+  assert(result.command === 'agent', 'command should be agent');
+  assert(result.agentSubcommand === 'rm', 'agentSubcommand should be rm');
+  assert(result.name === 'abc', 'name should be abc');
+});
+
+runTest('args-parser: functional - parse "pave agent rm" (no name)', () => {
+  const parseArgs = require(path.join(__dirname, '..', 'lib', 'args-parser.js')).parseArgs;
+  const result = parseArgs(['agent', 'rm']);
+  assert(result.command === 'agent', 'command should be agent');
+  assert(result.agentSubcommand === 'rm', 'agentSubcommand should be rm');
+  assert(!result.commandArgs || result.commandArgs.length === 0, 'no commandArgs');
+});
+
+// ============================================================
+// 2. index.js: handleAgentRm function structure
+// ============================================================
+
+runTest('index.js: handleAgentRm function exists', () => {
+  assert(paveSource.indexOf('async function handleAgentRm(') !== -1,
+    'handleAgentRm should be an async function');
+});
+
+runTest('index.js: rm subcommand is dispatched to handleAgentRm', () => {
+  const dispatchIdx = paveSource.indexOf("agentSubcommand === 'rm'");
+  assert(dispatchIdx !== -1, 'should dispatch rm subcommand');
+  const section = paveSource.substring(dispatchIdx, dispatchIdx + 200);
+  assert(section.indexOf('handleAgentRm') !== -1,
+    'rm dispatch should call handleAgentRm');
+});
+
+runTest('index.js: handleAgentRm requires agent name', () => {
+  const section = getRmFuncSection();
+  assert(section.indexOf('Agent name is required') !== -1,
+    'should error if agent name is not provided');
+});
+
+runTest('index.js: handleAgentRm uses resolveAgentName for prefix matching', () => {
+  const section = getRmFuncSection();
+  assert(section.indexOf('resolveAgentName') !== -1,
+    'should use resolveAgentName for prefix matching');
+});
+
+runTest('index.js: handleAgentRm handles conflicting positional and --name', () => {
+  const section = getRmFuncSection();
+  assert(section.indexOf('Conflicting agent names') !== -1,
+    'should detect and error on conflicting agent names');
+});
+
+// ============================================================
+// 3. Liveness check uses isAgentAlive (not state strings)
+// ============================================================
+
+runTest('index.js: handleAgentRm uses isAgentAlive for liveness check', () => {
+  const section = getRmFuncSection();
+  assert(section.indexOf('isAgentAlive(agentName)') !== -1,
+    'should use isAgentAlive for authoritative liveness check');
+});
+
+runTest('index.js: handleAgentRm checks .alive property not state strings', () => {
+  const section = getRmFuncSection();
+  assert(section.indexOf('.alive') !== -1,
+    'should check .alive property from isAgentAlive result');
+  // Must NOT check specific state strings for running detection
+  assert(section.indexOf("status.state === 'working'") === -1,
+    'should NOT compare state === working');
+  assert(section.indexOf("status.state === 'sleeping'") === -1,
+    'should NOT compare state === sleeping');
+});
+
+// ============================================================
+// 4. Refused removal when alive without --force
+// ============================================================
+
+runTest('index.js: handleAgentRm refuses running agent without --force', () => {
+  const section = getRmFuncSection();
+  assert(section.indexOf('currently running') !== -1,
+    'should tell user the agent is currently running');
+  assert(section.indexOf('pave agent rm --force') !== -1,
+    'should suggest --force in error message');
+});
+
+// ============================================================
+// 5. Force path delegates to registry.stopAgent()
+// ============================================================
+
+runTest('index.js: handleAgentRm --force uses registry.stopAgent()', () => {
+  const section = getRmFuncSection();
+  assert(section.indexOf('stopAgent(agentName') !== -1,
+    'should use registry.stopAgent to stop the agent');
+  // Must NOT hand-roll SIGTERM/SIGKILL
+  assert(section.indexOf("process.kill(pid, 'SIGTERM')") === -1,
+    'should NOT hand-roll process.kill SIGTERM');
+  assert(section.indexOf("process.kill(pid, 'SIGKILL')") === -1,
+    'should NOT hand-roll process.kill SIGKILL');
+});
+
+runTest('index.js: handleAgentRm --force warns but proceeds on stop failure', () => {
+  const section = getRmFuncSection();
+  // Per issue #289: --force removes even if stop fails
+  assert(section.indexOf('stopResult.success') !== -1 ||
+         section.indexOf('!stopResult.success') !== -1,
+  'should check stopResult.success');
+  assert(section.indexOf('Failed to stop agent') !== -1,
+    'should warn when stop fails');
+  // Should NOT abort (return 1) when stop fails — must proceed to removal
+  assert(section.indexOf('Proceeding with removal anyway') !== -1,
+    'should proceed with removal even when stop fails (--force semantics)');
+});
+
+runTest('index.js: handleAgentRm --force does NOT abort on stop failure', () => {
+  const section = getRmFuncSection();
+  // Should NOT say "Cannot remove" — that would mean aborting on stop failure
+  assert(section.indexOf('Cannot remove a running agent') === -1,
+    'should NOT abort removal when stop fails (--force means remove anyway)');
+});
+
+runTest('index.js: handleAgentRm --force re-checks liveness after successful stop', () => {
+  const section = getRmFuncSection();
+  const stopIdx = section.indexOf('stopAgent(agentName');
+  assert(stopIdx !== -1, 'should call stopAgent');
+  const afterStop = section.substring(stopIdx);
+  // After stopAgent succeeds, should re-check isAgentAlive to guard against restart races
+  assert(afterStop.indexOf('isAgentAlive(agentName)') !== -1,
+    'should re-check isAgentAlive after stopAgent to guard against restart races');
+  // The re-check should warn but still proceed (--force semantics)
+  assert(afterStop.indexOf('restarted by another process') !== -1 ||
+         afterStop.indexOf('was restarted') !== -1,
+  'should warn about restart race but still proceed with removal');
+});
+
+runTest('index.js: handleAgentRm does NOT use listAgents for existence check', () => {
+  const section = getRmFuncSection();
+  // Should NOT use listAgents() — it can silently return empty on readdirSync errors,
+  // causing rm to report "not found" when the agent actually exists.
+  assert(section.indexOf('listAgents()') === -1,
+    'should NOT use listAgents() for existence check — rely on removeAgent result instead');
+});
+
+// ============================================================
+// 6. registry: removeAgent
+// ============================================================
+
+runTest('agent-registry: removeAgent function exists', () => {
+  assert(registrySource.indexOf('function removeAgent(') !== -1,
+    'removeAgent function should exist');
+});
+
+runTest('agent-registry: removeAgent is exported', () => {
+  const exportIdx = registrySource.indexOf('module.exports');
+  assert(exportIdx !== -1, 'should have module.exports');
+  const exportBlock = registrySource.substring(exportIdx);
+  assert(exportBlock.indexOf('removeAgent') !== -1,
+    'removeAgent should be exported');
+});
+
+runTest('agent-registry: removeAgent uses fs.rmSync recursive', () => {
+  const body = getRemoveAgentBody();
+  assert(body.indexOf('fs.rmSync(') !== -1,
+    'should use fs.rmSync for removal');
+  assert(body.indexOf('recursive: true') !== -1,
+    'should use recursive: true option');
+  // force:true is NOT required — using force:false with ENOENT catch is equally valid
+  // and gives more explicit error semantics
+});
+
+runTest('agent-registry: removeAgent does NOT use piecemeal unlinkSync', () => {
+  const body = getRemoveAgentBody();
+  assert(body.indexOf('unlinkSync') === -1,
+    'should NOT use unlinkSync (rmSync recursive handles all)');
+  assert(body.indexOf('rmdirSync') === -1,
+    'should NOT use rmdirSync (rmSync recursive handles all)');
+});
+
+runTest('agent-registry: removeAgent returns result object', () => {
+  const body = getRemoveAgentBody();
+  assert(body.indexOf('removed: true') !== -1,
+    'should return { removed: true } on success');
+  assert(body.indexOf('removed: false') !== -1,
+    'should return { removed: false } when nothing to remove');
+});
+
+runTest('agent-registry: removeAgent only ignores ENOENT', () => {
+  const body = getRemoveAgentBody();
+  assert(body.indexOf('ENOENT') !== -1,
+    'should check for ENOENT specifically');
+  assert(body.indexOf('throw e') !== -1 || body.indexOf('throw err') !== -1,
+    'should re-throw non-ENOENT errors');
+});
+
+runTest('agent-registry: removeAgent JSDoc describes full cleanup', () => {
+  const funcIdx = registrySource.indexOf('function removeAgent(');
+  const jsdocStart = registrySource.lastIndexOf('/**', funcIdx);
+  const jsdoc = registrySource.substring(jsdocStart, funcIdx);
+  assert(jsdoc.indexOf('all associated files') !== -1 ||
+         jsdoc.indexOf('inbox') !== -1 || jsdoc.indexOf('recursive') !== -1,
+  'JSDoc should describe that removal is recursive / includes all associated files');
+});
+
+// ============================================================
+// 7. handleAgentRm uses removeAgent result
+// ============================================================
+
+runTest('index.js: handleAgentRm checks removeAgent result', () => {
+  const section = getRmFuncSection();
+  assert(section.indexOf('.removed') !== -1,
+    'should check removed property from removeAgent result');
+});
+
+runTest('index.js: handleAgentRm wraps removeAgent in try/catch', () => {
+  const section = getRmFuncSection();
+  const removeIdx = section.indexOf('removeAgent(agentName)');
+  assert(removeIdx !== -1, 'should call removeAgent');
+  // Should be inside try/catch
+  const tryIdx = section.lastIndexOf('try {', removeIdx);
+  const catchIdx = section.indexOf('catch (err)', removeIdx);
+  assert(tryIdx !== -1 && catchIdx !== -1,
+    'removeAgent call should be in try/catch');
+  assert(section.indexOf('Error removing agent') !== -1,
+    'should surface removeAgent errors to user');
+});
+
+// ============================================================
+// 8. Help text and documentation
+// ============================================================
+
+runTest('index.js: help SUBCOMMANDS includes rm', () => {
+  const helpIdx = paveSource.indexOf('SUBCOMMANDS:');
+  assert(helpIdx !== -1, 'should have SUBCOMMANDS section');
+  const helpSection = paveSource.substring(helpIdx, helpIdx + 2000);
+  assert(helpSection.indexOf('rm') !== -1,
+    'SUBCOMMANDS should list rm');
+  assert(helpSection.indexOf('--force') !== -1,
+    'rm help should mention --force');
+});
+
+runTest('index.js: USAGE section includes pave agent rm', () => {
+  const usageIdx = paveSource.indexOf('USAGE:');
+  assert(usageIdx !== -1, 'should have USAGE section');
+  const usageSection = paveSource.substring(usageIdx, usageIdx + 500);
+  assert(usageSection.indexOf('agent rm') !== -1,
+    'USAGE section should include agent rm');
+});
+
+runTest('index.js: OPTIONS documents --force flag', () => {
+  const optIdx = paveSource.indexOf('OPTIONS:');
+  assert(optIdx !== -1, 'should have OPTIONS section');
+  const optSection = paveSource.substring(optIdx, optIdx + 1000);
+  assert(optSection.indexOf('--force') !== -1,
+    'OPTIONS should document --force flag');
+});
+
+// ============================================================
+// 7. Copilot review round 4 fixes
+// ============================================================
+
+runTest('index.js: help text says stops not kills for --force', () => {
+  const helpIdx = paveSource.indexOf('SUBCOMMANDS:');
+  const helpSection = paveSource.substring(helpIdx, helpIdx + 2000);
+  let rmIdx = helpSection.indexOf('rm [name]');
+  if (rmIdx === -1) rmIdx = helpSection.indexOf('rm');
+  assert(rmIdx !== -1, 'rm should be in help');
+  const rmSection = helpSection.substring(rmIdx, rmIdx + 500);
+  assert(rmSection.indexOf('attempts to stop') !== -1,
+    'help should say "attempts to stop" (not "stops") for --force accuracy');
+  assert(rmSection.indexOf('kills the agent') === -1,
+    'help should NOT say kills the agent');
+});
+
+runTest('index.js: handleAgentRm avoids listAgents for existence check', () => {
+  const funcSection = getRmFuncSection();
+  // Should NOT use listAgents() which can silently return [] on readdirSync errors
+  assert(funcSection.indexOf('listAgents()') === -1,
+    'should NOT use listAgents which can silently fail on readdirSync errors');
+});
+
+runTest('agent-registry: removeAgent JSDoc documents throw behavior', () => {
+  const funcIdx = registrySource.indexOf('function removeAgent(');
+  const jsdocStart = registrySource.lastIndexOf('/**', funcIdx);
+  const jsdoc = registrySource.substring(jsdocStart, funcIdx);
+  assert(jsdoc.indexOf('@throws') !== -1 || jsdoc.indexOf('throw') !== -1,
+    'JSDoc should document throw behavior for non-ENOENT errors');
+});
+
+// ============================================================
+// 8. Copilot review round 7 fixes
+// ============================================================
+
+runTest('index.js: handleAgentRm prints candidate suggestions on resolve failure', () => {
+  const section = getRmFuncSection();
+  const resolveIdx = section.indexOf('resolveAgentName(nameArg)');
+  assert(resolveIdx !== -1, 'should call resolveAgentName');
+  const afterResolve = section.substring(resolveIdx, resolveIdx + 500);
+  assert(afterResolve.indexOf('resolved.candidates') !== -1,
+    'should check resolved.candidates on error');
+  assert(afterResolve.indexOf('Did you mean') !== -1,
+    'should print "Did you mean" hint with candidates');
+});
+
+runTest('index.js: handleAgentRm JSDoc says "attempts to stop" not "stops"', () => {
+  const funcIdx = paveSource.indexOf('async function handleAgentRm');
+  assert(funcIdx !== -1, 'should have handleAgentRm function');
+  const jsdocStart = paveSource.lastIndexOf('/**', funcIdx);
+  const jsdoc = paveSource.substring(jsdocStart, funcIdx);
+  assert(jsdoc.indexOf('attempts to stop') !== -1,
+    'JSDoc should say "attempts to stop" to reflect that removal proceeds even if stop fails');
+});
+
+runTest('agent-registry: removeAgent does not use existsSync pre-check', () => {
+  const body = getRemoveAgentBody();
+  assert(body.indexOf('existsSync') === -1,
+    'should NOT use existsSync pre-check (rmSync + ENOENT catch handles the race cleanly)');
+});
+
+runTest('agent-registry: removeAgent uses force:false (explicit ENOENT handling)', () => {
+  const body = getRemoveAgentBody();
+  // force:true is NOT used — ENOENT is caught explicitly for clearer semantics
+  assert(body.indexOf('force: true') === -1,
+    'should NOT use force: true (ENOENT is handled via explicit catch instead)');
+});
+
+// ============================================================
+// Summary
+// ============================================================
+
+console.log('\nTotal: ' + (passed + failed) + ', Passed: ' + passed + ', Failed: ' + failed);
+if (failed > 0) process.exitCode = 1;