agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/test/cleanup-command.spec.ts

@@ -0,0 +1,301 @@
+import fs from 'node:fs/promises';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { CleanupCommandHandler } from '../src/cli/cleanup-command-handler.js';
+import { TOOLS } from '../src/core/constants.js';
+
+function makeFrontMatter(data: Record<string, unknown>): string {
+  const lines = Object.entries(data).map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
+  return `---\n${lines.join('\n')}\n---\n## Body\n`;
+}
+
+function makeToolClient(callImpl = vi.fn(async () => ({ ok: true, data: {} }))) {
+  return { call: callImpl };
+}
+
+describe('CleanupCommandHandler', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_no_terminal_features_WHEN_cleanup_called_THEN_returns_empty', async () => {
+    vi.spyOn(fs, 'readFile').mockImplementation(async (filePath) => {
+      const p = String(filePath);
+      if (p.endsWith('index.json')) {
+        return JSON.stringify({ active: ['feature_a'], blocked: [], merged: [] });
+      }
+      if (p.endsWith('state.md')) {
+        return makeFrontMatter({ status: 'planning', last_updated: new Date().toISOString() });
+      }
+      throw new Error('not found');
+    });
+    vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
+
+    const handler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo');
+    const result = await handler.execute({ command: 'cleanup' });
+
+    expect(result).toMatchObject({ ok: true, data: { would_clean: [], cleaned: [] } });
+  });
+
+  it('GIVEN_terminal_features_past_grace_period_WHEN_dry_run_THEN_lists_without_deleting', async () => {
+    const pastDate = new Date(Date.now() - 7200 * 1000).toISOString(); // 2 hours ago
+
+    vi.spyOn(fs, 'readFile').mockImplementation(async (filePath) => {
+      const p = String(filePath);
+      if (p.endsWith('index.json')) {
+        return JSON.stringify({ active: ['feature_a'], blocked: [], merged: [] });
+      }
+      if (p.includes('feature_a') && p.endsWith('state.md')) {
+        return makeFrontMatter({ status: 'merged', last_updated: pastDate });
+      }
+      throw new Error('not found');
+    });
+    vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
+
+    const callMock = vi.fn();
+    const handler = new CleanupCommandHandler(makeToolClient(callMock) as never, 'run:test', '/repo');
+    const result = await handler.execute({ command: 'cleanup', dry_run: true });
+
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        would_clean: [{ feature_id: 'feature_a', reason: 'terminal status: merged' }],
+        cleaned: []
+      }
+    });
+    expect(callMock).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_terminal_features_past_grace_period_WHEN_yes_flag_THEN_deletes_features', async () => {
+    const pastDate = new Date(Date.now() - 7200 * 1000).toISOString();
+
+    vi.spyOn(fs, 'readFile').mockImplementation(async (filePath) => {
+      const p = String(filePath);
+      if (p.endsWith('index.json')) {
+        return JSON.stringify({ active: ['feature_a'], blocked: [], merged: [] });
+      }
+      if (p.includes('feature_a') && p.endsWith('state.md')) {
+        return makeFrontMatter({ status: 'failed', last_updated: pastDate });
+      }
+      throw new Error('not found');
+    });
+    vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
+
+    const callMock = vi.fn(async () => ({ ok: true, data: {} }));
+    const handler = new CleanupCommandHandler(makeToolClient(callMock) as never, 'run:test', '/repo');
+    const result = await handler.execute({ command: 'cleanup', yes: true });
+
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        would_clean: [{ feature_id: 'feature_a' }],
+        cleaned: [{ feature_id: 'feature_a' }]
+      }
+    });
+    expect(callMock).toHaveBeenCalledWith(
+      TOOLS.FEATURE_DELETE,
+      expect.objectContaining({ feature_id: 'feature_a', confirm: true, dry_run: false }),
+      expect.any(Object)
+    );
+  });
+
+  it('GIVEN_orphan_worktrees_WHEN_cleanup_dry_run_THEN_lists_orphans_without_deleting', async () => {
+    vi.spyOn(fs, 'readFile').mockImplementation(async (filePath) => {
+      const p = String(filePath);
+      if (p.endsWith('index.json')) {
+        return JSON.stringify({ active: ['feature_a'], blocked: [], merged: [] });
+      }
+      if (p.includes('feature_a') && p.endsWith('state.md')) {
+        return makeFrontMatter({ status: 'planning', last_updated: new Date().toISOString() });
+      }
+      throw new Error('not found');
+    });
+    vi.spyOn(fs, 'readdir').mockResolvedValue([
+      { name: 'orphan_feature', isDirectory: () => true },
+      { name: 'feature_a', isDirectory: () => true },
+      { name: 'not_a_dir.txt', isDirectory: () => false }
+    ] as never);
+
+    const callMock = vi.fn();
+    const handler = new CleanupCommandHandler(makeToolClient(callMock) as never, 'run:test', '/repo');
+    const result = await handler.execute({ command: 'cleanup', dry_run: true });
+
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        would_clean: [{ feature_id: 'orphan_feature', reason: 'orphan worktree' }],
+        cleaned: []
+      }
+    });
+    expect(callMock).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_eligible_feature_WHEN_deletion_throws_THEN_item_moves_to_skipped', async () => {
+    const pastDate = new Date(Date.now() - 7200 * 1000).toISOString();
+
+    vi.spyOn(fs, 'readFile').mockImplementation(async (filePath) => {
+      const p = String(filePath);
+      if (p.endsWith('index.json')) {
+        return JSON.stringify({ active: ['feature_a'], blocked: [], merged: [] });
+      }
+      if (p.includes('feature_a') && p.endsWith('state.md')) {
+        return makeFrontMatter({ status: 'failed', last_updated: pastDate });
+      }
+      throw new Error('not found');
+    });
+    vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
+
+    const callMock = vi.fn().mockRejectedValue(new Error('delete failed'));
+    const handler = new CleanupCommandHandler(makeToolClient(callMock) as never, 'run:test', '/repo');
+    const result = await handler.execute({ command: 'cleanup', yes: true });
+
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        would_clean: [{ feature_id: 'feature_a' }],
+        cleaned: [],
+        skipped: [{ feature_id: 'feature_a' }]
+      }
+    });
+  });
+
+  it('GIVEN_merged_feature_WHEN_auto_after_merge_enabled_THEN_cleanup_includes_merged_residue', async () => {
+    const pastDate = new Date(Date.now() - 7200 * 1000).toISOString();
+
+    vi.spyOn(fs, 'readFile').mockImplementation(async (filePath) => {
+      const p = String(filePath);
+      if (p.endsWith('index.json')) {
+        return JSON.stringify({ active: [], blocked: [], merged: ['feature_merged'] });
+      }
+      if (p.includes('feature_merged') && p.endsWith('state.md')) {
+        return makeFrontMatter({ status: 'merged', last_updated: pastDate });
+      }
+      throw new Error('not found');
+    });
+    vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
+
+    const defaultHandler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, false);
+    const defaultResult = await defaultHandler.execute({ command: 'cleanup', dry_run: true });
+    expect(defaultResult).toMatchObject({
+      ok: true,
+      data: {
+        would_clean: []
+      }
+    });
+
+    const autoHandler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, true);
+    const autoResult = await autoHandler.execute({ command: 'cleanup', dry_run: true });
+    expect(autoResult).toMatchObject({
+      ok: true,
+      data: {
+        would_clean: [{ feature_id: 'feature_merged', reason: 'terminal status: merged' }],
+        cleaned: []
+      }
+    });
+  });
+});
+
+describe('CleanupCommandHandler branch coverage', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_active_run_lease_WHEN_terminal_feature_past_grace_period_THEN_feature_skipped_as_lease_still_active', async () => {
+    const pastDate = new Date(Date.now() - 7200 * 1000).toISOString();
+    const futureExpiry = new Date(Date.now() + 7200 * 1000).toISOString();
+
+    vi.spyOn(fs, 'readFile').mockImplementation(async (filePath) => {
+      const p = String(filePath);
+      if (p.endsWith('index.json')) {
+        return JSON.stringify({ active: ['feature_active_lease'], blocked: [], merged: [] });
+      }
+      if (p.includes('feature_active_lease') && p.endsWith('state.md')) {
+        return makeFrontMatter({ status: 'failed', last_updated: pastDate });
+      }
+      if (p.endsWith('run-lease.json')) {
+        return JSON.stringify({ run_id: 'run:123', lease_expires_at: futureExpiry });
+      }
+      throw new Error('not found');
+    });
+    // Allow readdir to succeed with empty array so isRunLeaseInactive checks candidate paths
+    vi.spyOn(fs, 'readdir').mockResolvedValue([]);
+
+    const handler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, false);
+    const result = await handler.execute({ command: 'cleanup', dry_run: true });
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        would_clean: [],
+        skipped: [{ feature_id: 'feature_active_lease', reason: 'run lease still active' }]
+      }
+    });
+  });
+
+  it('GIVEN_terminal_feature_within_grace_period_WHEN_cleanup_called_THEN_feature_skipped_as_not_eligible', async () => {
+    const recentDate = new Date(Date.now() - 100 * 1000).toISOString();
+
+    vi.spyOn(fs, 'readFile').mockImplementation(async (filePath) => {
+      const p = String(filePath);
+      if (p.endsWith('index.json')) {
+        return JSON.stringify({ active: ['feature_grace_period'], blocked: [], merged: [] });
+      }
+      if (p.includes('feature_grace_period') && p.endsWith('state.md')) {
+        return makeFrontMatter({ status: 'failed', last_updated: recentDate });
+      }
+      throw new Error('not found');
+    });
+    vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
+
+    const handler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, false);
+    const result = await handler.execute({ command: 'cleanup', dry_run: true });
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        would_clean: [],
+        skipped: [{ feature_id: 'feature_grace_period', reason: 'not eligible' }]
+      }
+    });
+  });
+
+  it('GIVEN_auto_after_merge_and_merged_feature_without_state_WHEN_cleanup_called_THEN_eligible_as_merged_residue', async () => {
+    vi.spyOn(fs, 'readFile').mockImplementation(async (filePath) => {
+      const p = String(filePath);
+      if (p.endsWith('index.json')) {
+        return JSON.stringify({ active: [], blocked: [], merged: ['feature_no_state'] });
+      }
+      throw new Error('not found');
+    });
+    vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
+
+    const handler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, true);
+    const result = await handler.execute({ command: 'cleanup', dry_run: true });
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        would_clean: [{ feature_id: 'feature_no_state', reason: 'merged residue with missing state' }]
+      }
+    });
+  });
+});
+
+describe('CleanupCommandHandler state unreadable branch', () => {
+  it('GIVEN_active_feature_with_unreadable_state_WHEN_cleanup_called_THEN_skipped_as_state_unreadable', async () => {
+    vi.spyOn(fs, 'readFile').mockImplementation(async (filePath) => {
+      const p = String(filePath);
+      if (p.endsWith('index.json')) {
+        return JSON.stringify({ active: ['feature_bad_state'], blocked: [], merged: [] });
+      }
+      throw new Error('read error');
+    });
+    vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
+
+    const handler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, false);
+    const result = await handler.execute({ command: 'cleanup', dry_run: true });
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        would_clean: [],
+        skipped: [{ feature_id: 'feature_bad_state', reason: 'state unreadable' }]
+      }
+    });
+  });
+});