@iservu-inc/adf-cli 0.1.6 → 0.3.0

package/tests/cursor-generator.test.js

@@ -0,0 +1,326 @@
+const fs = require('fs-extra');
+const path = require('path');
+const CursorGenerator = require('../lib/generators/cursor-generator');
+
+const TEST_PROJECT_PATH = path.join(__dirname, 'test-project-cursor');
+const TEST_SESSION_PATH = path.join(TEST_PROJECT_PATH, '.adf', 'sessions', 'test-session');
+
+describe('CursorGenerator', () => {
+  beforeEach(async () => {
+    // Clean up test directories
+    await fs.remove(TEST_PROJECT_PATH);
+    await fs.ensureDir(TEST_PROJECT_PATH);
+    await fs.ensureDir(TEST_SESSION_PATH);
+    await fs.ensureDir(path.join(TEST_SESSION_PATH, 'outputs'));
+  });
+
+  afterEach(async () => {
+    // Clean up after tests
+    await fs.remove(TEST_PROJECT_PATH);
+  });
+
+  describe('PRP Framework', () => {
+    it('should generate Cursor configurations from PRP output', async () => {
+      // Create mock PRP output
+      const prpContent = `# Product Requirement Prompt (PRP)
+
+## 1. Goal Definition
+Build a React dashboard that displays real-time analytics from PostgreSQL database.
+
+## 2. Business Justification
+This will help users make data-driven decisions and improve productivity.
+
+## 3. Contextual Intelligence
+### Technology Stack
+- Frontend: React 18, TypeScript
+- Backend: Node.js, Express
+- Database: PostgreSQL
+
+## 4. Implementation Blueprint
+### File Structure
+- src/components/Dashboard/
+- src/api/analytics/
+
+### Core Logic
+1. Fetch data from analytics API
+2. Process and aggregate
+3. Render charts
+
+## 5. Validation
+### Success Criteria
+- Dashboard loads in <2s
+- All charts render correctly
+`;
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'prp.md'),
+        prpContent,
+        'utf-8'
+      );
+
+      // Create metadata
+      await fs.writeJson(path.join(TEST_SESSION_PATH, '_metadata.json'), {
+        framework: 'rapid',
+        projectName: 'Test Analytics Dashboard'
+      });
+
+      // Generate Cursor configs
+      const generator = new CursorGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      const generated = await generator.generate();
+
+      // Verify .cursor/rules was created
+      const rulesPath = path.join(TEST_PROJECT_PATH, '.cursor', 'rules');
+      expect(await fs.pathExists(rulesPath)).toBe(true);
+
+      const rulesContent = await fs.readFile(rulesPath, 'utf-8');
+      expect(rulesContent).toContain('Test Analytics Dashboard');
+      expect(rulesContent).toContain('Cursor Rules');
+      expect(rulesContent).toContain('Project Goal');
+      expect(rulesContent).toContain('React dashboard');
+      expect(rulesContent).toContain('Tech Stack');
+      expect(rulesContent).toContain('Before Implementing Features');
+      expect(rulesContent).toContain('.adf/sessions/test-session/outputs/prp.md');
+      expect(rulesContent).toContain('Code Standards');
+      expect(rulesContent).toContain('What to Avoid');
+
+      // Verify .cursorrules deprecation notice was created
+      const legacyPath = path.join(TEST_PROJECT_PATH, '.cursorrules');
+      expect(await fs.pathExists(legacyPath)).toBe(true);
+
+      const legacyContent = await fs.readFile(legacyPath, 'utf-8');
+      expect(legacyContent).toContain('DEPRECATED');
+      expect(legacyContent).toContain('.cursor/rules');
+      expect(legacyContent).toContain('Migration');
+
+      // Verify generated structure
+      expect(generated.rules).toHaveLength(1);
+      expect(generated.legacy).toHaveLength(1);
+    });
+  });
+
+  describe('Balanced Framework', () => {
+    it('should generate Cursor configurations from Balanced outputs', async () => {
+      // Create mock outputs
+      const constitutionContent = `# Constitution
+
+## Core Principles
+1. User privacy is paramount
+2. Performance over features
+
+## Constraints
+- No third-party analytics
+- WCAG 2.1 AA compliance
+`;
+
+      const specificationContent = `# Specification
+
+## Overview
+A comprehensive user management system.
+
+## Architecture
+Microservices architecture with API gateway.
+`;
+
+      const planContent = `# Technical Plan
+
+## Technology Stack
+- React 18
+- Node.js 20
+- PostgreSQL 15
+
+## Code Style
+- Use TypeScript strict mode
+- Follow Airbnb style guide
+
+## Coding Standards
+- Write tests first
+- Document public APIs
+`;
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'constitution.md'),
+        constitutionContent,
+        'utf-8'
+      );
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'specification.md'),
+        specificationContent,
+        'utf-8'
+      );
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'plan.md'),
+        planContent,
+        'utf-8'
+      );
+
+      await fs.writeJson(path.join(TEST_SESSION_PATH, '_metadata.json'), {
+        framework: 'balanced',
+        projectName: 'User Management System'
+      });
+
+      // Generate Cursor configs
+      const generator = new CursorGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'balanced');
+      await generator.generate();
+
+      // Verify .cursor/rules
+      const rulesPath = path.join(TEST_PROJECT_PATH, '.cursor', 'rules');
+      const rulesContent = await fs.readFile(rulesPath, 'utf-8');
+
+      expect(rulesContent).toContain('User Management System');
+      expect(rulesContent).toContain('Core Principles');
+      expect(rulesContent).toContain('User privacy is paramount');
+      expect(rulesContent).toContain('Constraints (Non-Negotiable)');
+      expect(rulesContent).toContain('WCAG 2.1 AA compliance');
+      expect(rulesContent).toContain('Microservices architecture');
+      expect(rulesContent).toContain('constitution.md');
+      expect(rulesContent).toContain('specification.md');
+      expect(rulesContent).toContain('plan.md');
+      expect(rulesContent).toContain('What You MUST NOT Do');
+    });
+  });
+
+  describe('BMAD Framework', () => {
+    it('should generate Cursor configurations from BMAD outputs', async () => {
+      // Create mock outputs
+      const prdContent = `# Product Requirements Document
+
+## Executive Summary
+A complete e-commerce platform for small businesses.
+
+## Goals and Objectives
+- Enable online sales
+- Provide analytics
+
+## Technical Requirements
+- RESTful API
+- Payment gateway integration
+- Secure checkout flow
+`;
+
+      const architectureContent = `# System Architecture
+
+## System Overview
+Modular monolith architecture with separate domains.
+
+## Architecture Overview
+Clean architecture with domain-driven design.
+
+## Components
+- Order Management
+- Inventory System
+- Payment Processing
+`;
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'prd.md'),
+        prdContent,
+        'utf-8'
+      );
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'architecture.md'),
+        architectureContent,
+        'utf-8'
+      );
+
+      await fs.writeJson(path.join(TEST_SESSION_PATH, '_metadata.json'), {
+        framework: 'comprehensive',
+        projectName: 'E-commerce Platform'
+      });
+
+      // Generate Cursor configs
+      const generator = new CursorGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'comprehensive');
+      await generator.generate();
+
+      // Verify .cursor/rules
+      const rulesPath = path.join(TEST_PROJECT_PATH, '.cursor', 'rules');
+      const rulesContent = await fs.readFile(rulesPath, 'utf-8');
+
+      expect(rulesContent).toContain('E-commerce Platform');
+      expect(rulesContent).toContain('Product Overview');
+      expect(rulesContent).toContain('e-commerce platform');
+      expect(rulesContent).toContain('Goals and Objectives');
+      expect(rulesContent).toContain('Enable online sales');
+      expect(rulesContent).toContain('System Architecture');
+      expect(rulesContent).toContain('Code Quality Standards');
+      expect(rulesContent).toContain('Security');
+      expect(rulesContent).toContain('Performance');
+      expect(rulesContent).toContain('prd.md');
+      expect(rulesContent).toContain('architecture.md');
+      expect(rulesContent).toContain('stories.md');
+    });
+  });
+
+  describe('Modern vs Legacy', () => {
+    it('should create modern .cursor/rules as primary config', async () => {
+      const prpContent = '# PRP\n\n## 1. Goal Definition\nTest project';
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'prp.md'),
+        prpContent,
+        'utf-8'
+      );
+
+      const generator = new CursorGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      const generated = await generator.generate();
+
+      // Modern config should exist
+      const modernPath = path.join(TEST_PROJECT_PATH, '.cursor', 'rules');
+      expect(await fs.pathExists(modernPath)).toBe(true);
+
+      // Legacy should be deprecation notice
+      const legacyPath = path.join(TEST_PROJECT_PATH, '.cursorrules');
+      expect(await fs.pathExists(legacyPath)).toBe(true);
+
+      const legacyContent = await fs.readFile(legacyPath, 'utf-8');
+      expect(legacyContent).toContain('DEPRECATED');
+    });
+  });
+
+  describe('Template Variables', () => {
+    it('should replace session ID in paths', async () => {
+      const prpContent = '# PRP\n\n## 1. Goal Definition\nTest project';
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'prp.md'),
+        prpContent,
+        'utf-8'
+      );
+
+      const generator = new CursorGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      await generator.generate();
+
+      const rulesContent = await fs.readFile(
+        path.join(TEST_PROJECT_PATH, '.cursor', 'rules'),
+        'utf-8'
+      );
+
+      // Should contain the actual session ID, not a template variable
+      expect(rulesContent).toContain('test-session');
+      expect(rulesContent).not.toContain('{SESSION_ID}');
+    });
+
+    it('should include ADF CLI version', async () => {
+      const prpContent = '# PRP\n\n## 1. Goal Definition\nTest';
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'prp.md'),
+        prpContent,
+        'utf-8'
+      );
+
+      const generator = new CursorGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      await generator.generate();
+
+      const rulesContent = await fs.readFile(
+        path.join(TEST_PROJECT_PATH, '.cursor', 'rules'),
+        'utf-8'
+      );
+
+      expect(rulesContent).toContain('Generated by');
+      expect(rulesContent).toContain('ADF CLI');
+    });
+  });
+});

package/tests/progress-tracker.test.js

@@ -0,0 +1,205 @@
+const fs = require('fs-extra');
+const path = require('path');
+const ProgressTracker = require('../lib/frameworks/progress-tracker');
+
+const TEST_SESSION_PATH = path.join(__dirname, 'test-session');
+
+describe('ProgressTracker', () => {
+  beforeEach(async () => {
+    // Clean up test session directory
+    await fs.remove(TEST_SESSION_PATH);
+    await fs.ensureDir(TEST_SESSION_PATH);
+  });
+
+  afterEach(async () => {
+    // Clean up after tests
+    await fs.remove(TEST_SESSION_PATH);
+  });
+
+  describe('initialize', () => {
+    it('should create new progress file for new session', async () => {
+      const tracker = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      const isResumable = await tracker.initialize();
+
+      expect(isResumable).toBe(false);
+      expect(await fs.pathExists(path.join(TEST_SESSION_PATH, '_progress.json'))).toBe(true);
+      expect(await fs.pathExists(path.join(TEST_SESSION_PATH, '_progress-log.md'))).toBe(true);
+    });
+
+    it('should load existing progress for resumable session', async () => {
+      // Create initial session
+      const tracker1 = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      await tracker1.initialize();
+      await tracker1.startBlock(1, 'Test Block');
+
+      // Resume session
+      const tracker2 = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      const isResumable = await tracker2.initialize();
+
+      expect(isResumable).toBe(true);
+      expect(tracker2.getProgress().currentBlock).toBe(1);
+    });
+  });
+
+  describe('answerQuestion', () => {
+    it('should save answer with quality metrics', async () => {
+      const tracker = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      await tracker.initialize();
+
+      const qualityMetrics = {
+        wordCount: 50,
+        qualityScore: 85,
+        isComprehensive: true,
+        hasKeywords: { matched: ['react', 'web'], count: 2 },
+        hasRequiredElements: { detected: ['platform'], count: 1 }
+      };
+
+      await tracker.answerQuestion('q1', 'What are you building?', 'A React web app', qualityMetrics);
+
+      const progress = tracker.getProgress();
+      expect(progress.answers['q1']).toBeDefined();
+      expect(progress.answers['q1'].text).toBe('A React web app');
+      expect(progress.answers['q1'].quality.qualityScore).toBe(85);
+      expect(progress.totalWordCount).toBe(50);
+      expect(progress.comprehensiveAnswers).toBe(1);
+    });
+
+    it('should calculate average answer quality correctly', async () => {
+      const tracker = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      await tracker.initialize();
+
+      await tracker.answerQuestion('q1', 'Q1', 'Answer 1', { qualityScore: 80, wordCount: 20, isComprehensive: true });
+      await tracker.answerQuestion('q2', 'Q2', 'Answer 2', { qualityScore: 90, wordCount: 30, isComprehensive: true });
+      await tracker.answerQuestion('q3', 'Q3', 'Answer 3', { qualityScore: 70, wordCount: 25, isComprehensive: true });
+
+      const progress = tracker.getProgress();
+      expect(progress.averageAnswerQuality).toBe(80); // (80+90+70)/3 = 80
+    });
+
+    it('should calculate information richness based on quality and completion', async () => {
+      const tracker = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      await tracker.initialize();
+
+      // Complete 2 of 5 blocks (40% completion)
+      await tracker.completeBlock(1, 'Block 1', 3);
+      await tracker.completeBlock(2, 'Block 2', 2);
+
+      // Add high-quality answers (90% quality)
+      await tracker.answerQuestion('q1', 'Q1', 'A1', { qualityScore: 90, wordCount: 50, isComprehensive: true });
+      await tracker.answerQuestion('q2', 'Q2', 'A2', { qualityScore: 90, wordCount: 50, isComprehensive: true });
+
+      const progress = tracker.getProgress();
+      // informationRichness = (0.4 * completionFactor) + (0.6 * qualityFactor)
+      // = (0.4 * 0.4) + (0.6 * 0.9) = 0.16 + 0.54 = 0.70 = 70%
+      expect(progress.informationRichness).toBeCloseTo(70, 0);
+    });
+  });
+
+  describe('saveWithBackup', () => {
+    it('should create triple-redundant saves', async () => {
+      const tracker = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      await tracker.initialize();
+
+      await tracker.answerQuestion('q1', 'Q1', 'Answer', { qualityScore: 75, wordCount: 20, isComprehensive: true });
+
+      // Check all three save locations exist
+      expect(await fs.pathExists(path.join(TEST_SESSION_PATH, '_progress.json'))).toBe(true);
+      expect(await fs.pathExists(path.join(TEST_SESSION_PATH, '_progress.backup.json'))).toBe(true);
+      expect(await fs.pathExists(path.join(TEST_SESSION_PATH, '_progress-log.md'))).toBe(true);
+
+      // Verify main and backup have same content
+      const main = await fs.readJson(path.join(TEST_SESSION_PATH, '_progress.json'));
+      const backup = await fs.readJson(path.join(TEST_SESSION_PATH, '_progress.backup.json'));
+      expect(main).toEqual(backup);
+    });
+
+    it('should create emergency save on error', async () => {
+      const tracker = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      await tracker.initialize();
+
+      // Make main file read-only to simulate save error
+      const mainFile = path.join(TEST_SESSION_PATH, '_progress.json');
+      await fs.chmod(mainFile, 0o444);
+
+      try {
+        await tracker.answerQuestion('q1', 'Q1', 'Answer', { qualityScore: 75, wordCount: 20, isComprehensive: true });
+      } catch (error) {
+        // May throw, but should still create emergency file
+      }
+
+      // Check for emergency file
+      const files = await fs.readdir(TEST_SESSION_PATH);
+      const emergencyFiles = files.filter(f => f.startsWith('_emergency-'));
+
+      // Restore permissions for cleanup
+      await fs.chmod(mainFile, 0o666);
+
+      // Emergency file should exist if save failed
+      expect(emergencyFiles.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('block tracking', () => {
+    it('should track block start, complete, and skip', async () => {
+      const tracker = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      await tracker.initialize();
+
+      await tracker.startBlock(1, 'Block 1');
+      await tracker.completeBlock(1, 'Block 1', 3);
+      await tracker.skipBlock(2, 'Block 2');
+
+      const progress = tracker.getProgress();
+      expect(progress.currentBlock).toBe(1);
+      expect(progress.completedBlocks.length).toBe(1);
+      expect(progress.completedBlocks[0].number).toBe(1);
+      expect(progress.completedBlocks[0].questionsAnswered).toBe(3);
+      expect(progress.skippedBlocks.length).toBe(1);
+      expect(progress.skippedBlocks[0].number).toBe(2);
+    });
+  });
+
+  describe('complete', () => {
+    it('should mark session as completed', async () => {
+      const tracker = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      await tracker.initialize();
+
+      await tracker.complete();
+
+      const progress = tracker.getProgress();
+      expect(progress.status).toBe('completed');
+      expect(progress.completedAt).toBeDefined();
+      expect(progress.canResume).toBe(false);
+    });
+  });
+
+  describe('canResume', () => {
+    it('should return true for in-progress sessions', async () => {
+      const tracker = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      await tracker.initialize();
+
+      expect(tracker.canResume()).toBe(true);
+    });
+
+    it('should return false for completed sessions', async () => {
+      const tracker = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      await tracker.initialize();
+      await tracker.complete();
+
+      expect(tracker.canResume()).toBe(false);
+    });
+  });
+
+  describe('getResumeInfo', () => {
+    it('should return resume information', async () => {
+      const tracker = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      await tracker.initialize();
+      await tracker.completeBlock(1, 'Block 1', 3); // This adds 3 to totalQuestionsAnswered
+      await tracker.answerQuestion('q1', 'Q1', 'A1', { qualityScore: 80, wordCount: 20, isComprehensive: true });
+
+      const info = tracker.getResumeInfo();
+      expect(info.completedBlocks).toBe(1);
+      expect(info.totalBlocks).toBe(5);
+      expect(info.totalQuestionsAnswered).toBe(3); // completeBlock added 3
+    });
+  });
+});

package/tests/session-manager.test.js

@@ -0,0 +1,162 @@
+const fs = require('fs-extra');
+const path = require('path');
+const SessionManager = require('../lib/frameworks/session-manager');
+const ProgressTracker = require('../lib/frameworks/progress-tracker');
+
+const TEST_PROJECT_PATH = path.join(__dirname, 'test-project');
+const TEST_SESSIONS_DIR = path.join(TEST_PROJECT_PATH, '.adf', 'sessions');
+
+describe('SessionManager', () => {
+  beforeEach(async () => {
+    // Clean up test project directory
+    await fs.remove(TEST_PROJECT_PATH);
+    await fs.ensureDir(TEST_PROJECT_PATH);
+  });
+
+  afterEach(async () => {
+    // Clean up after tests
+    await fs.remove(TEST_PROJECT_PATH);
+  });
+
+  describe('listSessions', () => {
+    it('should return empty array when no sessions exist', async () => {
+      const manager = new SessionManager(TEST_PROJECT_PATH);
+      const sessions = await manager.listSessions();
+
+      expect(sessions).toEqual([]);
+    });
+
+    it('should list all sessions with progress files', async () => {
+      const manager = new SessionManager(TEST_PROJECT_PATH);
+
+      // Create test sessions
+      const session1Path = path.join(TEST_SESSIONS_DIR, 'session-1');
+      const session2Path = path.join(TEST_SESSIONS_DIR, 'session-2');
+
+      await fs.ensureDir(session1Path);
+      await fs.ensureDir(session2Path);
+
+      // Create progress trackers
+      const tracker1 = new ProgressTracker(session1Path, 5, 'rapid');
+      await tracker1.initialize();
+
+      const tracker2 = new ProgressTracker(session2Path, 10, 'balanced');
+      await tracker2.initialize();
+
+      const sessions = await manager.listSessions();
+
+      expect(sessions.length).toBe(2);
+      expect(sessions[0].sessionId).toBe('session-1');
+      expect(sessions[1].sessionId).toBe('session-2');
+      expect(sessions[0].progress.framework).toBe('rapid');
+      expect(sessions[1].progress.framework).toBe('balanced');
+    });
+
+    it('should skip directories without progress files', async () => {
+      const manager = new SessionManager(TEST_PROJECT_PATH);
+
+      // Create session with progress
+      const session1Path = path.join(TEST_SESSIONS_DIR, 'session-1');
+      await fs.ensureDir(session1Path);
+      const tracker1 = new ProgressTracker(session1Path, 5, 'rapid');
+      await tracker1.initialize();
+
+      // Create directory without progress file
+      const session2Path = path.join(TEST_SESSIONS_DIR, 'session-2');
+      await fs.ensureDir(session2Path);
+
+      const sessions = await manager.listSessions();
+
+      expect(sessions.length).toBe(1);
+      expect(sessions[0].sessionId).toBe('session-1');
+    });
+  });
+
+  describe('getResumableSessions', () => {
+    it('should return only in-progress resumable sessions', async () => {
+      const manager = new SessionManager(TEST_PROJECT_PATH);
+
+      // Create in-progress session
+      const session1Path = path.join(TEST_SESSIONS_DIR, 'session-1');
+      await fs.ensureDir(session1Path);
+      const tracker1 = new ProgressTracker(session1Path, 5, 'rapid');
+      await tracker1.initialize();
+      await tracker1.startBlock(1, 'Block 1');
+
+      // Create completed session
+      const session2Path = path.join(TEST_SESSIONS_DIR, 'session-2');
+      await fs.ensureDir(session2Path);
+      const tracker2 = new ProgressTracker(session2Path, 5, 'rapid');
+      await tracker2.initialize();
+      await tracker2.complete();
+
+      const resumable = await manager.getResumableSessions();
+
+      expect(resumable.length).toBe(1);
+      expect(resumable[0].sessionId).toBe('session-1');
+      expect(resumable[0].progress.status).toBe('in-progress');
+      expect(resumable[0].progress.canResume).toBe(true);
+    });
+
+    it('should return empty array when no resumable sessions', async () => {
+      const manager = new SessionManager(TEST_PROJECT_PATH);
+
+      // Create completed session
+      const sessionPath = path.join(TEST_SESSIONS_DIR, 'session-1');
+      await fs.ensureDir(sessionPath);
+      const tracker = new ProgressTracker(sessionPath, 5, 'rapid');
+      await tracker.initialize();
+      await tracker.complete();
+
+      const resumable = await manager.getResumableSessions();
+
+      expect(resumable).toEqual([]);
+    });
+  });
+
+  describe('deleteSession', () => {
+    it('should delete session directory', async () => {
+      const manager = new SessionManager(TEST_PROJECT_PATH);
+
+      // Create session
+      const sessionPath = path.join(TEST_SESSIONS_DIR, 'session-1');
+      await fs.ensureDir(sessionPath);
+      const tracker = new ProgressTracker(sessionPath, 5, 'rapid');
+      await tracker.initialize();
+
+      expect(await fs.pathExists(sessionPath)).toBe(true);
+
+      await manager.deleteSession('session-1');
+
+      expect(await fs.pathExists(sessionPath)).toBe(false);
+    });
+  });
+
+  describe('deleteAllSessions', () => {
+    it('should delete all sessions and recreate directory', async () => {
+      const manager = new SessionManager(TEST_PROJECT_PATH);
+
+      // Create multiple sessions
+      const session1Path = path.join(TEST_SESSIONS_DIR, 'session-1');
+      const session2Path = path.join(TEST_SESSIONS_DIR, 'session-2');
+
+      await fs.ensureDir(session1Path);
+      await fs.ensureDir(session2Path);
+
+      const tracker1 = new ProgressTracker(session1Path, 5, 'rapid');
+      await tracker1.initialize();
+
+      const tracker2 = new ProgressTracker(session2Path, 5, 'rapid');
+      await tracker2.initialize();
+
+      expect(await fs.pathExists(session1Path)).toBe(true);
+      expect(await fs.pathExists(session2Path)).toBe(true);
+
+      await manager.deleteAllSessions();
+
+      expect(await fs.pathExists(session1Path)).toBe(false);
+      expect(await fs.pathExists(session2Path)).toBe(false);
+      expect(await fs.pathExists(TEST_SESSIONS_DIR)).toBe(true); // Directory should still exist
+    });
+  });
+});