jettypod 3.0.1

package/features/git-hooks/git-hooks.feature

@@ -0,0 +1,30 @@
+Feature: Git Hook Integration
+  As a developer
+  I want work item status to update automatically on git operations
+  So that I don't have to manually track progress
+
+  Scenario: First commit updates status to in_progress
+    Given I have a work item with status "todo"
+    And the work item is set as current work
+    When I make my first commit
+    Then the work item status should be "in_progress"
+
+  Scenario: Merge to main updates status to done
+    Given I have a work item with status "in_progress"
+    And the work item is set as current work
+    And I am on a feature branch
+    When I merge to main
+    Then the work item status should be "done"
+
+  Scenario: No current work item - hooks do nothing
+    Given no work item is set as current
+    When I make a commit
+    Then no errors occur
+
+  Scenario: Integration - hooks work with existing work commands
+    Given I have initialized jettypod with git
+    And I create a work item via work commands
+    And I start work on the item
+    When I commit changes
+    Then the work item status updates automatically
+    And the current work file still exists

package/features/git-hooks/index.js

@@ -0,0 +1,93 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Install JettyPod git hooks into .git/hooks directory
+ * @returns {boolean} True if hooks installed successfully, false if not a git repo
+ * @throws {Error} If hook files cannot be copied or made executable
+ */
+function installHooks() {
+  const gitHooksDir = path.join(process.cwd(), '.git', 'hooks');
+  const devpodHooksDir = path.join(__dirname);
+
+  if (!fs.existsSync(gitHooksDir)) {
+    console.log('⚠️  Not a git repository - skipping hook installation');
+    return false;
+  }
+
+  const hooks = ['pre-commit', 'post-commit', 'post-merge'];
+
+  hooks.forEach(hook => {
+    // Check both locations: features/git-hooks and .jettypod/hooks
+    let sourcePath = path.join(devpodHooksDir, hook);
+    if (!fs.existsSync(sourcePath)) {
+      sourcePath = path.join(process.cwd(), '.jettypod', 'hooks', hook);
+    }
+
+    if (!fs.existsSync(sourcePath)) {
+      console.log(`⚠️  Hook ${hook} not found, skipping`);
+      return;
+    }
+
+    const targetPath = path.join(gitHooksDir, hook);
+
+    try {
+      // Read hook content and inject module path
+      let hookContent = fs.readFileSync(sourcePath, 'utf-8');
+
+      // Find the jettypod root (where node_modules is)
+      const devpodRoot = path.dirname(require.main.filename);
+      const modulesPath = path.join(devpodRoot, 'node_modules');
+
+      // Inject NODE_PATH setup after shebang
+      if (hookContent.includes('require(\'sqlite3\')')) {
+        hookContent = hookContent.replace(
+          '#!/usr/bin/env node',
+          `#!/usr/bin/env node\n\n// Injected module path\nprocess.env.NODE_PATH = '${modulesPath}' + ':' + (process.env.NODE_PATH || '');require('module').Module._initPaths();`
+        );
+      }
+
+      // Replace __JETTYPOD_ROOT__ placeholder with actual jettypod root path
+      hookContent = hookContent.replace(/__JETTYPOD_ROOT__/g, devpodRoot);
+
+      fs.writeFileSync(targetPath, hookContent);
+
+      // Make executable
+      fs.chmodSync(targetPath, 0o755);
+    } catch (err) {
+      throw new Error(`Failed to install ${hook} hook: ${err.message}`);
+    }
+  });
+
+  console.log('✓ Git hooks installed (pre-commit, post-commit, post-merge)');
+  return true;
+}
+
+/**
+ * Check if JettyPod git hooks are installed
+ * @returns {boolean} True if hooks are installed
+ */
+function areHooksInstalled() {
+  const gitHooksDir = path.join(process.cwd(), '.git', 'hooks');
+  if (!fs.existsSync(gitHooksDir)) {
+    return false;
+  }
+
+  try {
+    const postCommitPath = path.join(gitHooksDir, 'post-commit');
+    if (!fs.existsSync(postCommitPath)) {
+      return false;
+    }
+
+    const content = fs.readFileSync(postCommitPath, 'utf-8');
+    return content.includes('JettyPod');
+  } catch (err) {
+    // If we can't read the file, assume not installed
+    return false;
+  }
+}
+
+module.exports = {
+  installHooks,
+  areHooksInstalled
+};

package/features/git-hooks/index.test.js

@@ -0,0 +1,137 @@
+const fs = require('fs');
+const path = require('path');
+const { createTestEnvironment } = require('../../lib/test-helpers');
+const { installHooks, areHooksInstalled } = require('./index');
+const { execSync } = require('child_process');
+
+describe('Git Hooks', () => {
+  let testEnv;
+
+  beforeEach(() => {
+    testEnv = createTestEnvironment();
+    process.chdir(testEnv.testDir);
+  });
+
+  afterEach(() => {
+    testEnv.cleanup();
+  });
+
+  describe('installHooks()', () => {
+    test('should return false if not a git repository', () => {
+      const result = installHooks();
+      expect(result).toBe(false);
+    });
+
+    test('should install hooks in git repository', () => {
+      // Initialize git repo
+      execSync('git init', { stdio: 'pipe' });
+
+      // Create source hooks
+      const hooksSourceDir = path.join(testEnv.testDir, 'features', 'git-hooks');
+      fs.mkdirSync(hooksSourceDir, { recursive: true });
+
+      fs.writeFileSync(path.join(hooksSourceDir, 'pre-commit'), '#!/usr/bin/env node\nconsole.log("test");');
+      fs.writeFileSync(path.join(hooksSourceDir, 'post-commit'), '#!/usr/bin/env node\n// JettyPod hook');
+      fs.writeFileSync(path.join(hooksSourceDir, 'post-merge'), '#!/usr/bin/env node\nconsole.log("test");');
+
+      const result = installHooks();
+
+      expect(result).toBe(true);
+      expect(fs.existsSync('.git/hooks/pre-commit')).toBe(true);
+      expect(fs.existsSync('.git/hooks/post-commit')).toBe(true);
+      expect(fs.existsSync('.git/hooks/post-merge')).toBe(true);
+    });
+
+    test('should make hooks executable', () => {
+      execSync('git init', { stdio: 'pipe' });
+
+      const hooksSourceDir = path.join(testEnv.testDir, 'features', 'git-hooks');
+      fs.mkdirSync(hooksSourceDir, { recursive: true });
+
+      fs.writeFileSync(path.join(hooksSourceDir, 'pre-commit'), '#!/usr/bin/env node\nconsole.log("test");');
+      fs.writeFileSync(path.join(hooksSourceDir, 'post-commit'), '#!/usr/bin/env node\n// DevPod');
+      fs.writeFileSync(path.join(hooksSourceDir, 'post-merge'), '#!/usr/bin/env node\nconsole.log("test");');
+
+      installHooks();
+
+      const preCommitPath = path.join(testEnv.testDir, '.git', 'hooks', 'pre-commit');
+      const stats = fs.statSync(preCommitPath);
+      // Check if executable bit is set (mode & 0o111)
+      expect(stats.mode & 0o111).not.toBe(0);
+    });
+
+    test('should succeed when hooks exist in production directory', () => {
+      execSync('git init', { stdio: 'pipe' });
+
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      // This will find hooks in the real features/git-hooks directory
+      const result = installHooks();
+
+      expect(result).toBe(true);
+      consoleSpy.mockRestore();
+    });
+
+    test('should check alternate hook location (.jettypod/hooks)', () => {
+      execSync('git init', { stdio: 'pipe' });
+
+      const altHooksDir = path.join(testEnv.testDir, '.jettypod', 'hooks');
+      fs.mkdirSync(altHooksDir, { recursive: true });
+
+      fs.writeFileSync(path.join(altHooksDir, 'pre-commit'), '#!/usr/bin/env node\nconsole.log("test");');
+      fs.writeFileSync(path.join(altHooksDir, 'post-commit'), '#!/usr/bin/env node\n// DevPod');
+      fs.writeFileSync(path.join(altHooksDir, 'post-merge'), '#!/usr/bin/env node\nconsole.log("test");');
+
+      const result = installHooks();
+
+      expect(result).toBe(true);
+      expect(fs.existsSync('.git/hooks/post-commit')).toBe(true);
+    });
+  });
+
+  describe('areHooksInstalled()', () => {
+    test('should return false if not a git repository', () => {
+      const result = areHooksInstalled();
+      expect(result).toBe(false);
+    });
+
+    test('should return false if hooks not installed', () => {
+      execSync('git init', { stdio: 'pipe' });
+
+      const result = areHooksInstalled();
+      expect(result).toBe(false);
+    });
+
+    test('should return true if JettyPod hooks installed', () => {
+      execSync('git init', { stdio: 'pipe' });
+
+      fs.writeFileSync('.git/hooks/post-commit', '#!/usr/bin/env node\n// JettyPod hook\nconsole.log("test");');
+
+      const result = areHooksInstalled();
+      expect(result).toBe(true);
+    });
+
+    test('should return false if hooks exist but are not JettyPod hooks', () => {
+      execSync('git init', { stdio: 'pipe' });
+
+      fs.writeFileSync('.git/hooks/post-commit', '#!/usr/bin/env node\nconsole.log("other hook");');
+
+      const result = areHooksInstalled();
+      expect(result).toBe(false);
+    });
+
+    test('should return false if hook file cannot be read', () => {
+      execSync('git init', { stdio: 'pipe' });
+
+      fs.writeFileSync('.git/hooks/post-commit', '#!/usr/bin/env node\n// DevPod');
+      fs.chmodSync('.git/hooks/post-commit', 0o000);
+
+      const result = areHooksInstalled();
+
+      // Cleanup
+      fs.chmodSync('.git/hooks/post-commit', 0o644);
+
+      expect(result).toBe(false);
+    });
+  });
+});

package/features/git-hooks/post-commit

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+// JettyPod Git Hook: post-commit
+// Auto-updates work item status and regenerates docs
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const jettypodDir = path.join(process.cwd(), '.jettypod');
+const currentWorkPath = path.join(jettypodDir, 'current-work.json');
+const dbPath = path.join(jettypodDir, 'work.db');
+
+// Update work item status if needed
+(async () => {
+  if (fs.existsSync(currentWorkPath)) {
+    const currentWork = JSON.parse(fs.readFileSync(currentWorkPath, 'utf-8'));
+
+    // Only update if status is todo
+    if (currentWork.status === 'todo') {
+      try {
+        const { updateStatus } = require('../../features/work-tracking');
+        await updateStatus(currentWork.id, 'in_progress');
+
+        // Update current work file
+        currentWork.status = 'in_progress';
+        fs.writeFileSync(currentWorkPath, JSON.stringify(currentWork, null, 2));
+
+        console.log(`\n✓ Work item #${currentWork.id} status updated: todo → in_progress`);
+      } catch (err) {
+        console.error('Failed to update work item:', err);
+      }
+    }
+  }
+})();
+
+// Always generate docs on every commit
+generateDocs();
+
+function generateDocs() {
+  const featuresDir = path.join(process.cwd(), 'features');
+  const outputPath = path.join(process.cwd(), 'SYSTEM-BEHAVIOR.md');
+
+  // Skip if no features directory
+  if (!fs.existsSync(featuresDir)) {
+    return;
+  }
+
+  try {
+    const docsGenerator = require(path.join(process.cwd(), 'lib', 'docs-generator'));
+    docsGenerator.generate();
+    console.log('📚 Documentation updated');
+  } catch (err) {
+    // Fail silently - docs generation is optional
+  }
+}

package/features/git-hooks/post-merge

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+// JettyPod Git Hook: post-merge
+// Auto-updates work item status to done when merging to main
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const jettypodDir = path.join(process.cwd(), '.jettypod');
+const currentWorkPath = path.join(jettypodDir, 'current-work.json');
+const dbPath = path.join(jettypodDir, 'work.db');
+
+// Skip if no current work
+if (!fs.existsSync(currentWorkPath)) {
+  process.exit(0);
+}
+
+// Check if we're on main/master
+let currentBranch;
+try {
+  currentBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+} catch (e) {
+  process.exit(0);
+}
+
+if (currentBranch !== 'main' && currentBranch !== 'master') {
+  process.exit(0);
+}
+
+const currentWork = JSON.parse(fs.readFileSync(currentWorkPath, 'utf-8'));
+
+// Update to done using shared updateStatus (includes epic auto-close logic)
+(async () => {
+  try {
+    const { updateStatus } = require('__JETTYPOD_ROOT__/features/work-tracking');
+    await updateStatus(currentWork.id, 'done');
+
+    // Clear current work pointer since work is done
+    fs.unlinkSync(currentWorkPath);
+
+    console.log(`\n✓ Work item #${currentWork.id} status updated: → done (merged to ${currentBranch})`);
+  } catch (err) {
+    console.error('Failed to update work item:', err);
+    process.exit(1);
+  }
+})();

package/features/git-hooks/pre-commit

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+// Pre-commit hook: Run tests before allowing commit
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Check if we're in a real project (not a test directory)
+const packageJsonPath = path.join(process.cwd(), 'package.json');
+if (!fs.existsSync(packageJsonPath)) {
+  // Skip tests in test directories
+  process.exit(0);
+}
+
+console.log('\n🧪 Running tests before commit...\n');
+
+try {
+  // Run tests
+  execSync('npm test', { stdio: 'inherit' });
+
+  console.log('\n✅ Tests passed! Proceeding with commit.\n');
+  process.exit(0);
+} catch (err) {
+  console.log('\n❌ Tests failed! Commit blocked.\n');
+  console.log('Fix the failing tests or use --no-verify to skip this check.\n');
+  process.exit(1);
+}

package/features/git-hooks/simple-steps.js

@@ -0,0 +1,53 @@
+const { Given, When, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const sqlite3 = require('sqlite3').verbose();
+
+const testDir = path.join('/tmp', 'hooks-simple-' + Date.now());
+const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
+let originalDir;
+let workItemId;
+
+Given('I initialize a git repo with devpod', function () {
+  originalDir = process.cwd();
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  process.chdir(testDir);
+
+  execSync('git init', { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+  execSync('git config user.name "Test"', { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe' });
+});
+
+Given('I create and start work on a todo item', function () {
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test"`, { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work status 1 todo`, { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work start 1`, { stdio: 'pipe' });
+  workItemId = 1;
+});
+
+Then('the hook updates status to in_progress', function () {
+  const dbPath = path.join(testDir, '.jettypod', dbFileName);
+  const db = new sqlite3.Database(dbPath);
+
+  return new Promise((resolve) => {
+    db.get(`SELECT status FROM work_items WHERE id = ?`, [workItemId], (err, row) => {
+      db.close();
+      assert.strictEqual(row.status, 'in_progress');
+
+      // Cleanup
+      if (fs.existsSync(testDir)) {
+        process.chdir(originalDir);
+        fs.rmSync(testDir, { recursive: true, force: true });
+      }
+
+      resolve();
+    });
+  });
+});

package/features/git-hooks/simple-test.feature

@@ -0,0 +1,10 @@
+Feature: Git Hooks Integration
+  As a developer
+  I want work item status to auto-update on commits
+  So I don't manually track progress
+
+  Scenario: Integration - post-commit hook updates status
+    Given I initialize a git repo with devpod
+    And I create and start work on a todo item
+    When I make a commit
+    Then the hook updates status to in_progress

package/features/git-hooks/steps.js

@@ -0,0 +1,196 @@
+const { Given, When, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const sqlite3 = require('sqlite3').verbose();
+
+const testDir = path.join('/tmp', 'jettypod-hooks-test-' + Date.now());
+const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
+let originalDir;
+
+// Helper to ensure NODE_ENV=test is always set for test execSync calls
+function testExecSync(command, options = {}) {
+  const env = { ...process.env, NODE_ENV: 'test', ...options.env };
+  return execSync(command, { ...options, env });
+}
+
+Given('I have initialized jettypod with git', function () {
+  originalDir = process.cwd();
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  process.chdir(testDir);
+
+  execSync('git init', { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+  execSync('git config user.name "Test"', { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe' });
+
+  // Verify hooks installed
+  const hookPath = path.join(testDir, '.git', 'hooks', 'post-commit');
+  this.hooksInstalled = fs.existsSync(hookPath);
+});
+
+Given('I create a work item via work commands', function () {
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test Feature"`, { stdio: 'pipe' });
+  this.workItemId = 1;
+});
+
+Given('I start work on the item', function () {
+  const jettypodPath = path.join(__dirname, '../../jettypod.js');
+  const workDir = process.cwd();
+  const workItemId = this.workItemId || 1;
+
+  testExecSync(`node ${jettypodPath} work start ${workItemId}`, { cwd: workDir, stdio: 'pipe' });
+});
+
+When('I commit changes', function () {
+  fs.writeFileSync('test.txt', 'test content');
+  execSync('git add .', { stdio: 'pipe' });
+  execSync('git commit -m "test commit"', { stdio: 'pipe' });
+});
+
+Then('the work item status updates automatically', function () {
+  const dbPath = path.join(testDir, '.jettypod', dbFileName);
+  const db = new sqlite3.Database(dbPath);
+
+  return new Promise((resolve) => {
+    db.get(`SELECT status FROM work_items WHERE id = ?`, [this.workItemId], (err, row) => {
+      db.close();
+      // Should be in_progress (updated by post-commit hook)
+      assert(row.status === 'in_progress' || row.status === 'backlog',
+        `Expected in_progress or backlog, got ${row.status}`);
+      resolve();
+    });
+  });
+});
+
+Then('the current work file still exists', function () {
+  const currentWorkPath = path.join(testDir, '.jettypod', 'current-work.json');
+  assert(fs.existsSync(currentWorkPath), 'Current work file should still exist');
+
+  // Cleanup
+  if (fs.existsSync(testDir)) {
+    process.chdir(originalDir);
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+});
+
+Given('I have a work item with status {string}', function (status) {
+  originalDir = process.cwd();
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  process.chdir(testDir);
+
+  execSync('git init', { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+  execSync('git config user.name "Test"', { stdio: 'pipe' });
+
+  // Make initial commit so branch exists
+  fs.writeFileSync('README.md', '# Test');
+  execSync('git add .', { stdio: 'pipe' });
+  execSync('git commit -m "Initial commit"', { stdio: 'pipe' });
+
+  // Store default branch name
+  this.defaultBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe' });
+
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test"`, { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work status 1 ${status}`, { stdio: 'pipe' });
+
+  this.workItemId = 1;
+  this.initialStatus = status;
+});
+
+Given('the work item is set as current work', function () {
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work start ${this.workItemId}`, { stdio: 'pipe' });
+});
+
+Given('I am on a feature branch', function () {
+  // Make initial commit on main so it exists
+  fs.writeFileSync('init.txt', 'init');
+  execSync('git add .', { stdio: 'pipe' });
+  execSync('git commit -m "initial commit"', { stdio: 'pipe' });
+
+  // Now create feature branch
+  execSync('git checkout -b feature/test', { stdio: 'pipe' });
+});
+
+When('I make my first commit', function () {
+  fs.writeFileSync('test.txt', 'test');
+  execSync('git add .', { stdio: 'pipe' });
+  execSync('git commit -m "first commit"', { stdio: 'pipe' });
+});
+
+When('I merge to main', function () {
+  // Commit on feature branch
+  fs.writeFileSync('feature.txt', 'feature');
+  execSync('git add .', { stdio: 'pipe' });
+  execSync('git commit -m "feature commit"', { stdio: 'pipe' });
+
+  // Switch to default branch and merge
+  execSync(`git checkout ${this.defaultBranch}`, { stdio: 'pipe' });
+  execSync('git merge feature/test --no-edit', { stdio: 'pipe' });
+});
+
+Then('the work item status should be {string}', function (expectedStatus) {
+  const dbPath = path.join(testDir, '.jettypod', dbFileName);
+
+  return new Promise((resolve) => {
+    // Give the post-merge hook time to complete
+    setTimeout(() => {
+      const db = new sqlite3.Database(dbPath);
+      db.get(`SELECT status FROM work_items WHERE id = ?`, [this.workItemId], (err, row) => {
+        db.close();
+        assert.strictEqual(row.status, expectedStatus);
+
+        // Cleanup
+        if (fs.existsSync(testDir)) {
+          process.chdir(originalDir);
+          fs.rmSync(testDir, { recursive: true, force: true });
+        }
+
+        resolve();
+      });
+    }, 50); // Small delay to ensure hook completes
+  });
+});
+
+Given('no work item is set as current', function () {
+  originalDir = process.cwd();
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  process.chdir(testDir);
+
+  execSync('git init', { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+  execSync('git config user.name "Test"', { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe' });
+});
+
+When('I make a commit', function () {
+  fs.writeFileSync('test.txt', 'test');
+  execSync('git add .', { stdio: 'pipe' });
+  execSync('git commit -m "test"', { stdio: 'pipe' });
+});
+
+Then('no errors occur', function () {
+  // If we got here, no errors occurred
+  assert(true);
+
+  // Cleanup
+  if (fs.existsSync(testDir)) {
+    process.chdir(originalDir);
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+});