@raftlabs/raftstack 1.9.3 → 1.10.0

package/dist/cli.js

@@ -215,6 +215,72 @@ async function hasPrettier(targetDir = process.cwd()) {
   }
   return false;
 }
+async function hasReact(targetDir = process.cwd()) {
+  try {
+    const pkgPath = join2(targetDir, "package.json");
+    if (existsSync2(pkgPath)) {
+      const content = await readFile(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      return "react" in deps || "react-dom" in deps;
+    }
+  } catch {
+  }
+  return false;
+}
+async function detectTestFramework(targetDir = process.cwd()) {
+  const vitestConfigFiles = [
+    "vitest.config.ts",
+    "vitest.config.js",
+    "vitest.config.mjs",
+    "vitest.config.cjs"
+  ];
+  for (const file of vitestConfigFiles) {
+    if (existsSync2(join2(targetDir, file))) {
+      return "vitest";
+    }
+  }
+  const jestConfigFiles = [
+    "jest.config.ts",
+    "jest.config.js",
+    "jest.config.mjs",
+    "jest.config.cjs",
+    "jest.config.json"
+  ];
+  for (const file of jestConfigFiles) {
+    if (existsSync2(join2(targetDir, file))) {
+      return "jest";
+    }
+  }
+  try {
+    const pkgPath = join2(targetDir, "package.json");
+    if (existsSync2(pkgPath)) {
+      const content = await readFile(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.jest) {
+        return "jest";
+      }
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if ("vitest" in deps) {
+        return "vitest";
+      }
+      if ("jest" in deps || "@jest/core" in deps) {
+        return "jest";
+      }
+      if (pkg.scripts?.test) {
+        const testScript = pkg.scripts.test;
+        if (testScript.includes("vitest")) {
+          return "vitest";
+        }
+        if (testScript.includes("jest")) {
+          return "jest";
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
 function getProjectTypeDescription(type) {
   switch (type) {
     case "nx":
@@ -386,6 +452,34 @@ async function promptPackageManager(targetDir) {
   }
   return getPackageManagerInfo(selected);
 }
+async function promptTestFramework(targetDir) {
+  const detected = await detectTestFramework(targetDir);
+  if (detected) {
+    p.log.info(`Detected ${pc.cyan(detected)} test framework`);
+    return detected;
+  }
+  p.log.warn("No test framework detected");
+  const selected = await p.select({
+    message: "Select a test framework:",
+    options: [
+      {
+        value: "vitest",
+        label: "Vitest",
+        hint: "Recommended for modern projects (fast, ESM-native)"
+      },
+      {
+        value: "jest",
+        label: "Jest",
+        hint: "Mature ecosystem, widely used"
+      }
+    ]
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return selected;
+}
 async function promptConfirmation(config) {
   console.log();
   p.note(
@@ -395,6 +489,7 @@ async function promptConfirmation(config) {
       `${pc.cyan("TypeScript:")} ${config.usesTypeScript ? "Yes" : "No"}`,
       `${pc.cyan("ESLint:")} ${config.usesEslint ? "Yes" : "No"}`,
       `${pc.cyan("Prettier:")} ${config.usesPrettier ? "Yes" : "No"}`,
+      `${pc.cyan("Test Framework:")} ${config.testFramework || "None"}`,
       `${pc.cyan("Asana Integration:")} ${config.asanaBaseUrl ? "Yes" : "No"}`,
       `${pc.cyan("AI Review:")} ${config.aiReviewTool === "none" ? "None" : config.aiReviewTool}`,
       `${pc.cyan("CODEOWNERS:")} ${config.codeowners.length > 0 ? config.codeowners.join(", ") : "None"}`
@@ -419,6 +514,16 @@ async function collectConfig(targetDir = process.cwd()) {
   const usesTypeScript = await hasTypeScript(targetDir);
   const usesEslint = await hasEslint(targetDir);
   const usesPrettier = await hasPrettier(targetDir);
+  const testFramework = await promptTestFramework(targetDir);
+  if (testFramework) {
+    p.note(
+      `${pc.green("\u2713")} TDD enforcement enabled:
+  \u2022 Tests run on commit (related tests)
+  \u2022 Full test suite + 80% coverage required on push
+  \u2022 Use ${pc.cyan("--no-verify")} to bypass (not recommended)`,
+      "Test-Driven Development"
+    );
+  }
   const asanaBaseUrl = await promptAsanaConfig();
   const aiReviewTool = await promptAIReview();
   const codeowners = await promptCodeowners();
@@ -430,7 +535,8 @@ async function collectConfig(targetDir = process.cwd()) {
     codeowners,
     usesTypeScript,
     usesEslint,
-    usesPrettier
+    usesPrettier,
+    testFramework
   };
   const confirmed = await promptConfirmation(config);
   if (!confirmed) {
@@ -508,17 +614,30 @@ function getBuildCommand(projectType) {
       return "pnpm build";
   }
 }
-function getPrePushHook(projectType) {
+function getPrePushHook(projectType, testFramework) {
   const buildCommand = getBuildCommand(projectType);
-  return `# Validate branch naming convention
+  let hook = `# Validate branch naming convention
 validate-branch-name
-
+`;
+  if (testFramework) {
+    hook += `
+# Run full test suite with coverage (STRICT - blocks on failure)
+echo "\u{1F9EA} Running full test suite with coverage..."
+npm run test:coverage || {
+  echo "\u274C Tests failed or coverage below 80%. Push blocked."
+  echo "\u{1F4A1} Fix failing tests or use 'git push --no-verify' to bypass (not recommended)."
+  exit 1
+}
+`;
+  }
+  hook += `
 # Build all packages - push only succeeds if builds pass
 echo "\u{1F528} Building..."
 ${buildCommand}
 `;
+  return hook;
 }
-async function generateHuskyHooks(targetDir, projectType, _pm) {
+async function generateHuskyHooks(targetDir, projectType, _pm, testFramework) {
   const result = {
     created: [],
     modified: [],
@@ -552,10 +671,14 @@ async function generateHuskyHooks(targetDir, projectType, _pm) {
     }
   }
   const prePushPath = join4(huskyDir, "pre-push");
-  const prePushResult = await writeFileSafe(prePushPath, getPrePushHook(projectType), {
-    executable: true,
-    backup: true
-  });
+  const prePushResult = await writeFileSafe(
+    prePushPath,
+    getPrePushHook(projectType, testFramework),
+    {
+      executable: true,
+      backup: true
+    }
+  );
   if (prePushResult.created) {
     result.created.push(".husky/pre-push");
     if (prePushResult.backedUp) {
@@ -727,7 +850,7 @@ async function generateCzGit(targetDir, _asanaBaseUrl) {
 }
 
 // src/generators/lint-staged.ts
-function getLintStagedConfig(usesEslint, usesPrettier, usesTypeScript) {
+function getLintStagedConfig(usesEslint, usesPrettier, usesTypeScript, testFramework) {
   const config = {};
   const codePatterns = [];
   if (usesTypeScript) {
@@ -741,6 +864,13 @@ function getLintStagedConfig(usesEslint, usesPrettier, usesTypeScript) {
   if (usesPrettier) {
     codeCommands.push("prettier --write");
   }
+  if (testFramework) {
+    if (testFramework === "vitest") {
+      codeCommands.push("vitest related --run --passWithNoTests");
+    } else {
+      codeCommands.push("jest --bail --findRelatedTests --passWithNoTests");
+    }
+  }
   if (codeCommands.length > 0) {
     const pattern = `*.{${codePatterns.join(",")}}`;
     config[pattern] = codeCommands;
@@ -933,11 +1063,18 @@ ${asanaSection}## Changes Made
 <!-- List the specific changes made in this PR -->
 -
 
+## Development Process
+<!-- Mark completed items with an "x" -->
+- [ ] Tests written BEFORE implementation (TDD)
+- [ ] All tests pass locally (\`npm run test\`)
+- [ ] Coverage maintained/improved (\`npm run test:coverage\`)
+
 ## Testing
 <!-- Describe how you tested your changes -->
 - [ ] Unit tests added/updated
 - [ ] Integration tests added/updated
 - [ ] Manual testing performed
+- [ ] Coverage: [X]% (target: 80%+)
 
 ## Screenshots (if applicable)
 <!-- Add screenshots to help explain your changes -->
@@ -980,7 +1117,7 @@ async function generatePRTemplate(targetDir, hasAsana) {
 
 // src/generators/github-workflows.ts
 import { join as join9 } from "path";
-function getPRChecksWorkflow(projectType, usesTypeScript, usesEslint, pm) {
+function getPRChecksWorkflow(projectType, usesTypeScript, usesEslint, pm, testFramework) {
   const steps = [];
   steps.push(`      - name: Checkout
         uses: actions/checkout@v4`);
@@ -1022,18 +1159,38 @@ function getPRChecksWorkflow(projectType, usesTypeScript, usesEslint, pm) {
       - name: Build
         run: ${pm.run} build`);
   }
-  if (projectType === "nx") {
+  if (testFramework) {
+    if (projectType === "nx") {
+      steps.push(`
+      - name: Test with Coverage
+        run: ${pm.run} nx affected --target=test --parallel=3 --coverage`);
+    } else if (projectType === "turbo") {
+      steps.push(`
+      - name: Test with Coverage
+        run: ${pm.run} turbo test:coverage`);
+    } else {
+      steps.push(`
+      - name: Test with Coverage
+        run: ${pm.run} test:coverage`);
+    }
     steps.push(`
+      - name: Check Coverage Threshold
+        run: |
+          echo "\u2705 Coverage check passed (80% threshold enforced by test config)"`);
+  } else {
+    if (projectType === "nx") {
+      steps.push(`
       - name: Test
         run: ${pm.run} nx affected --target=test --parallel=3`);
-  } else if (projectType === "turbo") {
-    steps.push(`
+    } else if (projectType === "turbo") {
+      steps.push(`
       - name: Test
         run: ${pm.run} turbo test`);
-  } else {
-    steps.push(`
+    } else {
+      steps.push(`
       - name: Test
         run: ${pm.run} test`);
+    }
   }
   return `name: PR Checks
 
@@ -1053,7 +1210,7 @@ jobs:
 ${steps.join("\n")}
 `;
 }
-async function generateGitHubWorkflows(targetDir, projectType, usesTypeScript, usesEslint, pm) {
+async function generateGitHubWorkflows(targetDir, projectType, usesTypeScript, usesEslint, pm, testFramework) {
   const result = {
     created: [],
     modified: [],
@@ -1065,7 +1222,13 @@ async function generateGitHubWorkflows(targetDir, projectType, usesTypeScript, u
   const prChecksPath = join9(workflowsDir, "pr-checks.yml");
   const writeResult = await writeFileSafe(
     prChecksPath,
-    getPRChecksWorkflow(projectType, usesTypeScript, usesEslint, pm),
+    getPRChecksWorkflow(
+      projectType,
+      usesTypeScript,
+      usesEslint,
+      pm,
+      testFramework
+    ),
     { backup: true }
   );
   if (writeResult.created) {
@@ -1444,14 +1607,53 @@ Includes user profile sync and token refresh.
 Closes #123
 \`\`\`
 ${asanaSection}
+## Test-Driven Development (TDD)
+
+We enforce TDD to ensure code quality and maintainability. **Write tests before implementation.**
+
+### TDD Workflow
+
+1. **Write a failing test** - Define expected behavior
+2. **Write minimal code to pass** - Implement just enough to make it green
+3. **Refactor** - Improve code while tests stay green
+
+### Running Tests
+
+\`\`\`bash
+# Watch mode (during development)
+${pm.run} test:watch
+
+# Run all tests
+${pm.run} test
+
+# Check coverage
+${pm.run} test:coverage
+\`\`\`
+
+### Coverage Requirements
+
+- **Minimum:** 80% coverage (lines, functions, branches, statements)
+- **Critical paths:** Aim for 100% coverage
+- **New features:** Must include tests before merging
+
+### Git Hooks
+
+Tests run automatically:
+- **Pre-commit:** Related tests for changed files
+- **Pre-push:** Full test suite with coverage check
+
+To bypass (not recommended): \`git push --no-verify\`
+
 ## Pull Request Process
 
 1. Ensure your branch is up to date with \`main\`/\`master\`
-2. Run tests and linting locally
-3. Create a pull request using the provided template
-4. Request review from code owners
-5. Address any feedback
-6. Merge once approved and all checks pass
+2. **Write tests first (TDD)**
+3. Run tests and linting locally
+4. **Verify coverage** (\`${pm.run} test:coverage\`)
+5. Create a pull request using the provided template
+6. Request review from code owners
+7. Address any feedback
+8. Merge once approved and all checks pass
 
 ### PR Size Guidelines
 
@@ -1475,9 +1677,11 @@ If your PR is large:
 
 Before committing, the following checks run automatically:
 
+- **Testing**: Related tests run on commit, full suite on push
 - **Linting**: ESLint checks for code quality
 - **Formatting**: Prettier ensures consistent style
 - **Type checking**: TypeScript validates types
+- **Coverage**: 80% minimum enforced on push
 - **Commit messages**: Commitlint validates format
 - **Branch names**: validate-branch-name checks naming
 
@@ -1708,7 +1912,8 @@ import { join as join17, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function getPackageConfigDir() {
   const currentFilePath = fileURLToPath3(import.meta.url);
-  const packageRoot = join17(dirname4(currentFilePath), "..");
+  const currentDir = dirname4(currentFilePath);
+  const packageRoot = currentDir.endsWith("dist") ? join17(currentDir, "..") : join17(currentDir, "..", "..");
   return join17(packageRoot, ".claude");
 }
 async function copyDirectory3(srcDir, destDir, result, baseDir) {
@@ -1742,17 +1947,22 @@ async function generateClaudeConfig(targetDir) {
   const packageConfigDir = getPackageConfigDir();
   const targetClaudeDir = join17(targetDir, ".claude");
   await ensureDir(targetClaudeDir);
-  const settingsContent = JSON.stringify({ model: "opusplan" }, null, 2) + "\n";
-  const settingsResult = await writeFileSafe(
-    join17(targetClaudeDir, "settings.json"),
-    settingsContent,
-    { backup: true }
-  );
-  if (settingsResult.created) {
-    result.created.push(".claude/settings.json");
-    if (settingsResult.backedUp) {
-      result.backedUp.push(settingsResult.backedUp);
+  const packageSettingsPath = join17(packageConfigDir, "settings.json");
+  const targetSettingsPath = join17(targetClaudeDir, "settings.json");
+  if (existsSync7(packageSettingsPath)) {
+    if (existsSync7(targetSettingsPath)) {
+      const backupPath = await backupFile(targetSettingsPath);
+      if (backupPath) {
+        const relativePath = backupPath.replace(targetDir + "/", "");
+        result.backedUp.push(relativePath);
+      }
     }
+    await copyFile4(packageSettingsPath, targetSettingsPath);
+    result.created.push(".claude/settings.json");
+  } else {
+    console.warn(
+      "Warning: settings.json not found in package. Skipping settings generation."
+    );
   }
   const packageSubagentsDir = join17(packageConfigDir, "subagents");
   const targetSubagentsDir = join17(targetClaudeDir, "subagents");
@@ -1770,7 +1980,7 @@ async function generateClaudeConfig(targetDir) {
 import { existsSync as existsSync8 } from "fs";
 import { readFile as readFile4 } from "fs/promises";
 import { join as join18 } from "path";
-async function hasReact(targetDir) {
+async function hasReact2(targetDir) {
   try {
     const pkgPath = join18(targetDir, "package.json");
     if (existsSync8(pkgPath)) {
@@ -2035,7 +2245,7 @@ export default [
 `;
 }
 async function detectReact(targetDir) {
-  return hasReact(targetDir);
+  return hasReact2(targetDir);
 }
 async function detectNextJs(targetDir) {
   return hasNextJs(targetDir);
@@ -2052,7 +2262,7 @@ async function generateEslint(targetDir, usesTypeScript, force = false) {
     return result;
   }
   const usesNextJs = await hasNextJs(targetDir);
-  const usesReact = await hasReact(targetDir);
+  const usesReact = await hasReact2(targetDir);
   let config;
   if (usesNextJs && usesTypeScript) {
     config = generateNextJsConfig();
@@ -2136,6 +2346,41 @@ git push -u origin feature/my-feature
 
 ---
 
+## \u{1F9EA} Test-Driven Development (TDD)
+
+### TDD Workflow
+
+1. **Write the test first** (red phase)
+2. **Write minimal code to pass** (green phase)
+3. **Refactor** with confidence (tests stay green)
+
+### Test Commands
+
+\`\`\`bash
+# Run tests in watch mode (during development)
+${pm.run} test:watch
+
+# Run all tests once
+${pm.run} test
+
+# Run tests with coverage report
+${pm.run} test:coverage
+\`\`\`
+
+### Git Hooks with Testing
+
+- **Pre-commit:** Runs related tests for changed files
+- **Pre-push:** Runs full test suite with 80% coverage requirement
+- **Bypass (not recommended):** \`git push --no-verify\`
+
+### Coverage Requirements
+
+- **Minimum:** 80% coverage for lines, functions, branches, statements
+- **Critical paths:** Aim for 100%
+- **New features:** Must include tests before merging
+
+---
+
 ## \u{1F4DD} Commit Types
 
 | Type | Emoji | Use For |
@@ -2158,7 +2403,9 @@ git push -u origin feature/my-feature
 Before submitting:
 - [ ] Branch name follows convention
 - [ ] All commits have task links
-- [ ] Tests pass locally
+- [ ] **Tests written before implementation (TDD)**
+- [ ] **All tests pass** (\`${pm.run} test\`)
+- [ ] **Coverage \u2265 80%** (\`${pm.run} test:coverage\`)
 - [ ] PR description filled out
 - [ ] Size is reasonable (< 400 lines)
 
@@ -2178,6 +2425,12 @@ ${pm.run} lint
 
 # Run tests
 ${pm.run} test
+
+# Run tests with coverage
+${pm.run} test:coverage
+
+# Run tests in watch mode
+${pm.run} test:watch
 \`\`\`
 
 ---
@@ -2523,12 +2776,200 @@ async function generateSharedConfigs(targetDir, projectType) {
   return result;
 }
 
+// src/generators/testing.ts
+import { join as join21 } from "path";
+var TEST_DEPENDENCIES = {
+  vitest: [
+    "vitest",
+    // ^2.1.0
+    "@vitest/coverage-v8"
+    // ^2.1.0
+  ],
+  jest: [
+    "jest",
+    // ^29.7.0
+    "@types/jest",
+    // ^29.5.0
+    "ts-jest"
+    // ^29.2.0
+  ]
+};
+var REACT_TEST_PACKAGES = [
+  "@testing-library/react",
+  // ^16.1.0
+  "@testing-library/jest-dom",
+  // ^6.6.0
+  "@testing-library/user-event"
+  // ^14.6.0
+];
+function getVitestConfig(projectType) {
+  if (projectType !== "single") {
+    return `import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html", "lcov"],
+      thresholds: {
+        lines: 80,
+        functions: 80,
+        branches: 80,
+        statements: 80,
+      },
+    },
+  },
+});
+`;
+  }
+  return `import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html", "lcov"],
+      thresholds: {
+        lines: 80,
+        functions: 80,
+        branches: 80,
+        statements: 80,
+      },
+      exclude: [
+        "node_modules/**",
+        "dist/**",
+        "build/**",
+        "**/*.config.{js,ts,mjs,cjs}",
+        "**/*.test.{js,ts,jsx,tsx}",
+        "**/__tests__/**",
+      ],
+    },
+  },
+});
+`;
+}
+function getJestConfig(projectType) {
+  const isMonorepo2 = projectType !== "single";
+  return `/** @type {import('jest').Config} */
+const config = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  ${isMonorepo2 ? "" : 'roots: ["<rootDir>/src"],\n  '}testMatch: ["**/__tests__/**/*.test.ts", "**/*.test.ts"],
+  collectCoverageFrom: [
+    "src/**/*.{ts,tsx}",
+    "!src/**/*.d.ts",
+    "!src/**/*.config.{ts,js}",
+  ],
+  coverageThresholds: {
+    global: {
+      lines: 80,
+      functions: 80,
+      branches: 80,
+      statements: 80,
+    },
+  },
+  coverageReporters: ["text", "json", "html", "lcov"],
+};
+
+module.exports = config;
+`;
+}
+function getTestSetupFile(framework) {
+  if (framework === "vitest") {
+    return `import "@testing-library/jest-dom/vitest";
+`;
+  }
+  return `import "@testing-library/jest-dom";
+`;
+}
+function getTestScripts(framework) {
+  if (framework === "vitest") {
+    return {
+      test: "vitest run",
+      "test:watch": "vitest",
+      "test:coverage": "vitest run --coverage",
+      "test:ui": "vitest --ui"
+    };
+  }
+  return {
+    test: "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  };
+}
+async function generateTestingSetup(targetDir, framework, projectType) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  const configFileName = framework === "vitest" ? "vitest.config.ts" : "jest.config.js";
+  const configPath = join21(targetDir, configFileName);
+  const configContent = framework === "vitest" ? getVitestConfig(projectType) : getJestConfig(projectType);
+  const configResult = await writeFileSafe(configPath, configContent, {
+    backup: true
+  });
+  if (configResult.created) {
+    result.created.push(configPath);
+  } else if (configResult.modified) {
+    result.modified.push(configPath);
+    if (configResult.backedUp) result.backedUp.push(configPath);
+  } else {
+    result.skipped.push(configPath);
+  }
+  const isReactProject = await hasReact(targetDir);
+  if (isReactProject) {
+    const setupFileName = framework === "vitest" ? "vitest.setup.ts" : "jest.setup.ts";
+    const setupPath = join21(targetDir, setupFileName);
+    const setupContent = getTestSetupFile(framework);
+    const setupResult = await writeFileSafe(setupPath, setupContent, {
+      backup: true
+    });
+    if (setupResult.created) {
+      result.created.push(setupPath);
+    } else if (setupResult.modified) {
+      result.modified.push(setupPath);
+      if (setupResult.backedUp) result.backedUp.push(setupPath);
+    } else {
+      result.skipped.push(setupPath);
+    }
+    if (framework === "vitest") {
+      const updatedConfig = getVitestConfig(projectType).replace(
+        'environment: "node",',
+        `environment: "jsdom",
+    setupFiles: ["./vitest.setup.ts"],`
+      );
+      await writeFileSafe(configPath, updatedConfig, { backup: true });
+    } else {
+      const updatedConfig = getJestConfig(projectType).replace(
+        'testEnvironment: "node",',
+        `testEnvironment: "jsdom",
+  setupFilesAfterEnv: ["<rootDir>/jest.setup.ts"],`
+      );
+      await writeFileSafe(configPath, updatedConfig, { backup: true });
+    }
+  }
+  return result;
+}
+function getTestDependencies(framework, includeReact) {
+  const baseDeps = TEST_DEPENDENCIES[framework];
+  if (includeReact) {
+    return [...baseDeps, ...REACT_TEST_PACKAGES];
+  }
+  return baseDeps;
+}
+
 // src/utils/git.ts
 import { execa } from "execa";
 import { existsSync as existsSync9 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 async function isGitRepo(targetDir = process.cwd()) {
-  if (existsSync9(join21(targetDir, ".git"))) {
+  if (existsSync9(join22(targetDir, ".git"))) {
     return true;
   }
   try {
@@ -2595,13 +3036,18 @@ async function updateProjectPackageJson(targetDir, config) {
     if (config.usesTypeScript) {
       scripts.typecheck = "tsc --noEmit";
     }
+    if (config.testFramework) {
+      const testScripts = getTestScripts(config.testFramework);
+      Object.assign(scripts, testScripts);
+    }
     pkg = mergeScripts(pkg, scripts, false);
     const lintStagedConfig = getLintStagedConfig(
       true,
       // usesEslint - always true now since we install it
       true,
       // usesPrettier - always true now since we install it
-      config.usesTypeScript
+      config.usesTypeScript,
+      config.testFramework
     );
     pkg = addPackageJsonConfig(pkg, "lint-staged", lintStagedConfig, true);
     await writePackageJson(pkg, targetDir);
@@ -2641,6 +3087,10 @@ async function runInit(targetDir = process.cwd()) {
   } else if (usesReact) {
     packagesToInstall = [...packagesToInstall, ...REACT_ESLINT_PACKAGES];
   }
+  if (config.testFramework) {
+    const testDeps = getTestDependencies(config.testFramework, usesReact);
+    packagesToInstall = [...packagesToInstall, ...testDeps];
+  }
   installSpinner.start("Installing dependencies...");
   const installResult = await installPackages(
     config.packageManager,
@@ -2669,13 +3119,23 @@ async function runInit(targetDir = process.cwd()) {
   const results = [];
   try {
     results.push(
-      await generateHuskyHooks(targetDir, config.projectType, config.packageManager)
+      await generateHuskyHooks(
+        targetDir,
+        config.projectType,
+        config.packageManager,
+        config.testFramework
+      )
     );
     results.push(await generateCommitlint(targetDir, config.asanaBaseUrl));
     results.push(await generateCzGit(targetDir, config.asanaBaseUrl));
     results.push(await generateBranchValidation(targetDir));
     results.push(await generateEslint(targetDir, config.usesTypeScript, false));
     results.push(await generatePrettier(targetDir));
+    if (config.testFramework) {
+      results.push(
+        await generateTestingSetup(targetDir, config.testFramework, config.projectType)
+      );
+    }
     if (isMonorepo(config.projectType)) {
       results.push(await generateSharedConfigs(targetDir, config.projectType));
     }
@@ -2687,7 +3147,8 @@ async function runInit(targetDir = process.cwd()) {
         config.usesTypeScript,
         true,
         // usesEslint - always true now
-        config.packageManager
+        config.packageManager,
+        config.testFramework
       )
     );
     results.push(await generateCodeowners(targetDir, config.codeowners));
@@ -3699,7 +4160,7 @@ async function runInstallCommands(targetDir = process.cwd()) {
 // package.json
 var package_default = {
   name: "@raftlabs/raftstack",
-  version: "1.9.3",
+  version: "1.10.0",
   description: "CLI tool for setting up Git hooks, commit conventions, and GitHub integration",
   type: "module",
   main: "./dist/index.js",