@iservu-inc/adf-cli 0.1.6 → 0.2.0

package/lib/frameworks/session-manager.js

@@ -0,0 +1,100 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+/**
+ * Session Manager
+ * Manages interview sessions - list, resume, delete
+ */
+
+class SessionManager {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.sessionsDir = path.join(projectPath, '.adf', 'sessions');
+  }
+
+  async listSessions() {
+    await fs.ensureDir(this.sessionsDir);
+    const sessions = await fs.readdir(this.sessionsDir);
+
+    const sessionDetails = [];
+
+    for (const sessionId of sessions) {
+      const sessionPath = path.join(this.sessionsDir, sessionId);
+      const progressFile = path.join(sessionPath, '_progress.json');
+
+      if (await fs.pathExists(progressFile)) {
+        const progress = await fs.readJson(progressFile);
+        sessionDetails.push({
+          sessionId,
+          sessionPath,
+          progress
+        });
+      }
+    }
+
+    return sessionDetails;
+  }
+
+  async getResumableSessions() {
+    const sessions = await this.listSessions();
+    return sessions.filter(s => s.progress.status === 'in-progress' && s.progress.canResume);
+  }
+
+  async promptToResume() {
+    const resumableSessions = await this.getResumableSessions();
+
+    if (resumableSessions.length === 0) {
+      return null; // No sessions to resume
+    }
+
+    console.log(chalk.cyan.bold('\n📂 Found Previous Interview Sessions\n'));
+
+    const choices = resumableSessions.map(s => {
+      const framework = s.sessionId.split('_').pop();
+      const date = new Date(s.progress.lastUpdated).toLocaleString();
+      const completion = Math.round((s.progress.completedBlocks.length / s.progress.totalBlocks) * 100);
+
+      return {
+        name: `${framework.toUpperCase()} | ${date} | ${completion}% complete (${s.progress.totalQuestionsAnswered} questions)`,
+        value: s.sessionId,
+        short: s.sessionId
+      };
+    });
+
+    choices.push({
+      name: chalk.gray('Start a new interview'),
+      value: 'new',
+      short: 'New interview'
+    });
+
+    const { choice } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'choice',
+        message: 'Resume previous interview or start new?',
+        choices
+      }
+    ]);
+
+    if (choice === 'new') {
+      return null;
+    }
+
+    const session = resumableSessions.find(s => s.sessionId === choice);
+    return session;
+  }
+
+  async deleteSession(sessionId) {
+    const sessionPath = path.join(this.sessionsDir, sessionId);
+    await fs.remove(sessionPath);
+  }
+
+  async deleteAllSessions() {
+    await fs.remove(this.sessionsDir);
+    await fs.ensureDir(this.sessionsDir);
+  }
+}
+
+module.exports = SessionManager;

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@iservu-inc/adf-cli",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "CLI tool for AgentDevFramework - AI-assisted development framework",
   "main": "index.js",
   "bin": {
     "adf": "bin/adf.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest --coverage",
+    "test:watch": "jest --watch"
   },
   "keywords": [
     "cli",
@@ -28,11 +29,11 @@
   "author": "iServU",
   "license": "MIT",
   "dependencies": {
-    "inquirer": "^8.2.5",
     "chalk": "^4.1.2",
-    "ora": "^5.4.1",
+    "commander": "^11.1.0",
     "fs-extra": "^11.2.0",
-    "commander": "^11.1.0"
+    "inquirer": "^8.2.5",
+    "ora": "^5.4.1"
   },
   "engines": {
     "node": ">=18.0.0",
@@ -48,5 +49,9 @@
   "homepage": "https://github.com/iservu/adf-cli#readme",
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.2",
+    "jest": "^30.2.0"
   }
 }

package/tests/answer-quality-analyzer.test.js

@@ -0,0 +1,173 @@
+const AnswerQualityAnalyzer = require('../lib/frameworks/answer-quality-analyzer');
+
+describe('AnswerQualityAnalyzer', () => {
+  describe('analyze', () => {
+    it('should score high-quality comprehensive answer highly', () => {
+      const question = {
+        keywords: ['react', 'typescript', 'web'],
+        requiredElements: ['platform', 'technology']
+      };
+
+      const answer = 'I am building a React 18 web dashboard using TypeScript and Node.js. ' +
+        'The platform is web-based, responsive design for desktop and mobile. ' +
+        'It will display real-time analytics data fetched from a PostgreSQL database. ' +
+        'Users can filter data by date range, export to CSV, and create custom views. ' +
+        'The tech stack includes Next.js 14 for the frontend, Express.js for the API, ' +
+        'and we will use Chart.js for data visualization. File structure will be ' +
+        'src/components/, src/api/, src/utils/. The main components are Dashboard, ' +
+        'DataTable, ChartView, and FilterPanel.';
+
+      const metrics = AnswerQualityAnalyzer.analyze(answer, question);
+
+      expect(metrics.qualityScore).toBeGreaterThan(80);
+      expect(metrics.isComprehensive).toBe(true);
+      expect(metrics.wordCount).toBeGreaterThan(50);
+      expect(metrics.hasKeywords.matched).toContain('react');
+      expect(metrics.hasKeywords.matched).toContain('typescript');
+      expect(metrics.hasRequiredElements.detected).toContain('platform');
+      expect(metrics.hasRequiredElements.detected).toContain('technology');
+    });
+
+    it('should score low-quality vague answer poorly', () => {
+      const question = {
+        keywords: ['react', 'typescript', 'nextjs'],
+        requiredElements: ['platform', 'technology']
+      };
+
+      const answer = 'An app';
+
+      const metrics = AnswerQualityAnalyzer.analyze(answer, question);
+
+      expect(metrics.qualityScore).toBeLessThan(30);
+      expect(metrics.isComprehensive).toBe(false);
+      expect(metrics.wordCount).toBeLessThan(5);
+      expect(metrics.hasKeywords.matched.length).toBe(0);
+    });
+
+    it('should detect bullet points and examples', () => {
+      const question = { keywords: [], requiredElements: [] };
+
+      const answer = 'The features include user authentication, dashboard, and export. ' +
+        'This allows for better security. ' +
+        'For example, users can click the export button to download CSV files.';
+
+      const metrics = AnswerQualityAnalyzer.analyze(answer, question);
+
+      expect(metrics.isDetailed.hasMultipleSentences).toBe(true);
+      expect(metrics.isDetailed.hasExamples).toBe(true);
+    });
+
+    it('should detect technical depth', () => {
+      const question = { keywords: [], requiredElements: [] };
+
+      const answer = 'Using React 18.2.0 with TypeScript. Will deploy to AWS using Docker containers. ' +
+        'Database is PostgreSQL 15. API endpoints follow REST conventions.';
+
+      const metrics = AnswerQualityAnalyzer.analyze(answer, question);
+
+      expect(metrics.hasTechnicalDepth.hasTechStack).toBe(true);
+      expect(metrics.hasTechnicalDepth.hasVersions).toBe(true);
+      expect(metrics.hasTechnicalDepth.hasSpecificTools).toBe(true);
+    });
+
+    it('should allow skipping follow-ups for excellent answers', () => {
+      const question = {
+        keywords: ['react', 'web', 'api'],
+        requiredElements: ['platform', 'technology', 'user-interaction']
+      };
+
+      const answer = 'Building a React web application with TypeScript and Next.js 14. ' +
+        'The platform is web-based, responsive design. Users can click buttons to submit forms, ' +
+        'search and filter data, and view real-time updates. Technology stack includes React 18, ' +
+        'TypeScript 5, Node.js 20, PostgreSQL 15, and Docker for deployment. ' +
+        'API endpoints: GET /api/users, POST /api/users, PUT /api/users/:id. ' +
+        'File structure: src/components/, src/pages/, src/api/, src/utils/. ' +
+        'Main components: UserList, UserForm, SearchBar, FilterPanel.';
+
+      const metrics = AnswerQualityAnalyzer.analyze(answer, question);
+
+      expect(metrics.canSkipFollowUps).toBe(true);
+      expect(metrics.qualityScore).toBeGreaterThanOrEqual(85);
+    });
+  });
+
+  describe('getFeedback', () => {
+    it('should return excellent feedback for score >= 90', () => {
+      const metrics = { qualityScore: 95 };
+      const feedback = AnswerQualityAnalyzer.getFeedback(metrics);
+      expect(feedback).toContain('Excellent');
+    });
+
+    it('should return good feedback for score >= 70', () => {
+      const metrics = { qualityScore: 75 };
+      const feedback = AnswerQualityAnalyzer.getFeedback(metrics);
+      expect(feedback).toContain('Great');
+    });
+
+    it('should return null for low scores', () => {
+      const metrics = { qualityScore: 45 };
+      const feedback = AnswerQualityAnalyzer.getFeedback(metrics);
+      expect(feedback).toBeNull();
+    });
+  });
+
+  describe('getWordCount', () => {
+    it('should count words correctly', () => {
+      expect(AnswerQualityAnalyzer.getWordCount('Hello world')).toBe(2);
+      expect(AnswerQualityAnalyzer.getWordCount('This is a test sentence.')).toBe(5);
+      expect(AnswerQualityAnalyzer.getWordCount('  Multiple   spaces   here  ')).toBe(3);
+    });
+  });
+
+  describe('checkKeywords', () => {
+    it('should match keywords case-insensitively', () => {
+      const result = AnswerQualityAnalyzer.checkKeywords(
+        'Using React and TypeScript',
+        ['react', 'typescript', 'node']
+      );
+
+      expect(result.matched).toContain('react');
+      expect(result.matched).toContain('typescript');
+      expect(result.count).toBe(2);
+      expect(result.total).toBe(3);
+    });
+  });
+
+  describe('checkRequiredElements', () => {
+    it('should detect platform element', () => {
+      const result = AnswerQualityAnalyzer.checkRequiredElements(
+        'This is a web application for mobile users',
+        ['platform']
+      );
+
+      expect(result.detected).toContain('platform');
+    });
+
+    it('should detect technology element', () => {
+      const result = AnswerQualityAnalyzer.checkRequiredElements(
+        'Built with React and Node.js',
+        ['technology']
+      );
+
+      expect(result.detected).toContain('technology');
+    });
+
+    it('should detect API endpoints', () => {
+      const result = AnswerQualityAnalyzer.checkRequiredElements(
+        'API has GET /api/users and POST /api/users endpoints',
+        ['api-endpoints']
+      );
+
+      expect(result.detected).toContain('api-endpoints');
+    });
+
+    it('should detect file paths', () => {
+      const result = AnswerQualityAnalyzer.checkRequiredElements(
+        'Files are in src/components/ and app/utils/helper.ts',
+        ['file-paths']
+      );
+
+      expect(result.detected).toContain('file-paths');
+    });
+  });
+});

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
+    });
+  });
+});