@iservu-inc/adf-cli 0.1.5 → 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.5",
+  "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/test-scenarios.sh

@@ -0,0 +1,134 @@
+#!/bin/bash
+
+# Comprehensive Test Script for @iservu-inc/adf-cli
+# Tests all major scenarios and validates outputs
+
+set -e  # Exit on error
+
+echo "=================================="
+echo "ADF CLI Comprehensive Test Suite"
+echo "=================================="
+echo ""
+
+# Colors
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+TEST_BASE_DIR="D:/Documents/GitHub/adf-cli-tests"
+PASS_COUNT=0
+FAIL_COUNT=0
+
+# Cleanup function
+cleanup() {
+    rm -rf "$TEST_BASE_DIR"
+    mkdir -p "$TEST_BASE_DIR"
+}
+
+# Test result function
+test_result() {
+    if [ $1 -eq 0 ]; then
+        echo -e "${GREEN}✓ PASS${NC}: $2"
+        ((PASS_COUNT++))
+    else
+        echo -e "${RED}✗ FAIL${NC}: $2"
+        ((FAIL_COUNT++))
+    fi
+}
+
+# Setup
+cleanup
+
+echo "=== Test 1: Rapid Workflow with Tool ===="
+cd "$TEST_BASE_DIR"
+mkdir test-rapid && cd test-rapid
+echo "# Test" > README.md
+printf "n\nn\n" | adf init --rapid --tool windsurf > /dev/null 2>&1
+test_result $? "Rapid workflow initialization"
+[ -f ".adf/context.json" ] && test_result 0 "context.json created" || test_result 1 "context.json missing"
+[ -f ".env.template" ] && test_result 0 ".env.template created" || test_result 1 ".env.template missing"
+[ -f ".windsurfrules" ] && test_result 0 ".windsurfrules created" || test_result 1 ".windsurfrules missing"
+[ -f ".framework/agents/dev.md" ] && test_result 0 "dev agent deployed" || test_result 1 "dev agent missing"
+[ -f ".framework/agents/qa.md" ] && test_result 0 "qa agent deployed" || test_result 1 "qa agent missing"
+WORKFLOW=$(cat .adf/context.json | grep -o '"workflow": "[^"]*"' | cut -d'"' -f4)
+[ "$WORKFLOW" = "rapid" ] && test_result 0 "Workflow is rapid" || test_result 1 "Workflow incorrect: $WORKFLOW"
+echo ""
+
+echo "=== Test 2: Balanced Workflow ===="
+cd "$TEST_BASE_DIR"
+mkdir test-balanced && cd test-balanced
+echo "# Test" > README.md
+printf "n\nn\n" | adf init --balanced --tool cursor > /dev/null 2>&1
+test_result $? "Balanced workflow initialization"
+[ -f ".cursorrules" ] && test_result 0 ".cursorrules created" || test_result 1 ".cursorrules missing"
+[ -f ".framework/agents/analyst.md" ] && test_result 0 "analyst agent deployed" || test_result 1 "analyst agent missing"
+[ -f ".framework/agents/pm.md" ] && test_result 0 "pm agent deployed" || test_result 1 "pm agent missing"
+WORKFLOW=$(cat .adf/context.json | grep -o '"workflow": "[^"]*"' | cut -d'"' -f4)
+[ "$WORKFLOW" = "balanced" ] && test_result 0 "Workflow is balanced" || test_result 1 "Workflow incorrect: $WORKFLOW"
+echo ""
+
+echo "=== Test 3: Comprehensive Workflow ===="
+cd "$TEST_BASE_DIR"
+mkdir test-comprehensive && cd test-comprehensive
+echo "# Test" > README.md
+printf "n\nn\n" | adf init --comprehensive --tool vscode > /dev/null 2>&1
+test_result $? "Comprehensive workflow initialization"
+[ -d ".vscode" ] && test_result 0 ".vscode directory created" || test_result 1 ".vscode missing"
+[ -f ".framework/agents/architect.md" ] && test_result 0 "architect agent deployed" || test_result 1 "architect agent missing"
+[ -f ".framework/agents/sm.md" ] && test_result 0 "sm agent deployed" || test_result 1 "sm agent missing"
+WORKFLOW=$(cat .adf/context.json | grep -o '"workflow": "[^"]*"' | cut -d'"' -f4)
+[ "$WORKFLOW" = "comprehensive" ] && test_result 0 "Workflow is comprehensive" || test_result 1 "Workflow incorrect: $WORKFLOW"
+echo ""
+
+echo "=== Test 4: Deploy Command ===="
+cd "$TEST_BASE_DIR/test-rapid"
+adf deploy cursor > /dev/null 2>&1
+test_result $? "Deploy to cursor"
+[ -f ".cursorrules" ] && test_result 0 "cursor config created" || test_result 1 "cursor config missing"
+echo ""
+
+echo "=== Test 5: Deploy List ===="
+OUTPUT=$(adf deploy --list 2>&1)
+echo "$OUTPUT" | grep -q "windsurf" && test_result 0 "windsurf in deploy list" || test_result 1 "windsurf not found"
+echo "$OUTPUT" | grep -q "cursor" && test_result 0 "cursor in deploy list" || test_result 1 "cursor not found"
+echo "$OUTPUT" | grep -q "claude-code" && test_result 0 "claude-code in deploy list" || test_result 1 "claude-code not found"
+echo ""
+
+echo "=== Test 6: Version Check ===="
+VERSION=$(adf --version 2>&1)
+test_result $? "Version command works"
+echo "Current version: $VERSION"
+echo ""
+
+echo "=== Test 7: Update Check ===="
+adf update --check > /dev/null 2>&1
+test_result $? "Update check command"
+echo ""
+
+echo "=== Test 8: Context.json Structure ===="
+cd "$TEST_BASE_DIR/test-rapid"
+cat .adf/context.json | grep -q '"version"' && test_result 0 "version field exists" || test_result 1 "version field missing"
+cat .adf/context.json | grep -q '"workflow"' && test_result 0 "workflow field exists" || test_result 1 "workflow field missing"
+cat .adf/context.json | grep -q '"documentationUrls"' && test_result 0 "documentationUrls field exists" || test_result 1 "documentationUrls field missing"
+cat .adf/context.json | grep -q '"documentationFiles"' && test_result 0 "documentationFiles field exists" || test_result 1 "documentationFiles field missing"
+cat .adf/context.json | grep -q '"agents"' && test_result 0 "agents field exists" || test_result 1 "agents field missing"
+echo ""
+
+echo "==================================="
+echo "Test Summary"
+echo "==================================="
+echo -e "${GREEN}Passed:${NC} $PASS_COUNT"
+echo -e "${RED}Failed:${NC} $FAIL_COUNT"
+echo ""
+
+# Cleanup
+cleanup
+
+if [ $FAIL_COUNT -eq 0 ]; then
+    echo -e "${GREEN}All tests passed!${NC}"
+    exit 0
+else
+    echo -e "${RED}Some tests failed${NC}"
+    exit 1
+fi

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