@nathapp/nax 0.40.0 → 0.40.1

package/dist/nax.js

@@ -17708,7 +17708,9 @@ var init_schemas3 = __esm(() => {
     testPath: exports_external.string().min(1, "acceptance.testPath must be non-empty"),
     model: exports_external.enum(["fast", "balanced", "powerful"]).default("fast"),
     refinement: exports_external.boolean().default(true),
-    redGate: exports_external.boolean().default(true)
+    redGate: exports_external.boolean().default(true),
+    testStrategy: exports_external.enum(["unit", "component", "cli", "e2e", "snapshot"]).optional(),
+    testFramework: exports_external.string().min(1, "acceptance.testFramework must be non-empty").optional()
   });
   TestCoverageConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
@@ -18362,14 +18364,16 @@ __export(exports_refinement, {
   buildRefinementPrompt: () => buildRefinementPrompt,
   _refineDeps: () => _refineDeps
 });
-function buildRefinementPrompt(criteria, codebaseContext) {
+function buildRefinementPrompt(criteria, codebaseContext, options) {
   const criteriaList = criteria.map((c, i) => `${i + 1}. ${c}`).join(`
 `);
+  const strategySection = buildStrategySection(options);
+  const refinedExample = buildRefinedExample(options?.testStrategy);
   return `You are an acceptance criteria refinement assistant. Your task is to convert raw acceptance criteria into concrete, machine-verifiable assertions.
 
 CODEBASE CONTEXT:
 ${codebaseContext}
-
+${strategySection}
 ACCEPTANCE CRITERIA TO REFINE:
 ${criteriaList}
 
@@ -18384,11 +18388,53 @@ Respond with ONLY a JSON array (no markdown code fences):
 
 Rules:
 - "original" must match the input criterion text exactly
-- "refined" must be a concrete assertion (e.g., "Function returns array of length N", "HTTP status 200 returned")
+- "refined" must be a concrete assertion (e.g., ${refinedExample})
 - "testable" is false only if the criterion cannot be automatically verified (e.g., "UX feels responsive", "design looks good")
 - "storyId" leave as empty string \u2014 it will be assigned by the caller
 - Respond with ONLY the JSON array`;
 }
+function buildStrategySection(options) {
+  if (!options?.testStrategy) {
+    return "";
+  }
+  const framework = options.testFramework ? ` Use ${options.testFramework} testing library syntax.` : "";
+  switch (options.testStrategy) {
+    case "component":
+      return `
+TEST STRATEGY: component
+Focus assertions on rendered output visible on screen \u2014 text content, visible elements, and screen state.
+Assert what the user sees rendered in the component, not what internal functions produce.${framework}
+`;
+    case "cli":
+      return `
+TEST STRATEGY: cli
+Focus assertions on stdout and stderr text output from the CLI command.
+Assert about terminal output content, exit codes, and standard output/standard error streams.${framework}
+`;
+    case "e2e":
+      return `
+TEST STRATEGY: e2e
+Focus assertions on HTTP response content \u2014 status codes, response bodies, and endpoint behavior.
+Assert about HTTP responses, status codes, and API endpoint output.${framework}
+`;
+    default:
+      return framework ? `
+TEST FRAMEWORK: ${options.testFramework}
+` : "";
+  }
+}
+function buildRefinedExample(testStrategy) {
+  switch (testStrategy) {
+    case "component":
+      return '"Text content visible on screen matches expected", "Rendered output contains expected element"';
+    case "cli":
+      return '"stdout contains expected text", "stderr is empty on success", "exit code is 0"';
+    case "e2e":
+      return '"HTTP status 200 returned", "Response body contains expected field", "Endpoint returns JSON"';
+    default:
+      return '"Array of length N returned", "HTTP status 200 returned"';
+  }
+}
 function parseRefinementResponse(response, criteria) {
   if (!response || !response.trim()) {
     return fallbackCriteria(criteria);
@@ -18412,7 +18458,7 @@ async function refineAcceptanceCriteria(criteria, context) {
   if (criteria.length === 0) {
     return [];
   }
-  const { storyId, codebaseContext, config: config2 } = context;
+  const { storyId, codebaseContext, config: config2, testStrategy, testFramework } = context;
   const logger = getLogger();
   const modelTier = config2.acceptance?.model ?? "fast";
   const modelEntry = config2.models[modelTier] ?? config2.models.fast;
@@ -18420,7 +18466,7 @@ async function refineAcceptanceCriteria(criteria, context) {
     throw new Error(`[refinement] config.models.${modelTier} not configured`);
   }
   const modelDef = resolveModel(modelEntry);
-  const prompt = buildRefinementPrompt(criteria, codebaseContext);
+  const prompt = buildRefinementPrompt(criteria, codebaseContext, { testStrategy, testFramework });
   let response;
   try {
     response = await _refineDeps.adapter.complete(prompt, {
@@ -18483,6 +18529,7 @@ async function generateFromPRD(_stories, refinedCriteria, options) {
   }
   const criteriaList = refinedCriteria.map((c, i) => `AC-${i + 1}: ${c.refined}`).join(`
 `);
+  const strategyInstructions = buildStrategyInstructions(options.testStrategy, options.testFramework);
   const prompt = `You are a test engineer. Generate acceptance tests for the "${options.featureName}" feature based on the refined acceptance criteria below.
 
 CODEBASE CONTEXT:
@@ -18491,7 +18538,7 @@ ${options.codebaseContext}
 ACCEPTANCE CRITERIA (refined):
 ${criteriaList}
 
-Generate a complete acceptance.test.ts file using bun:test framework. Each AC maps to exactly one test named "AC-N: <description>".
+${strategyInstructions}Generate a complete acceptance.test.ts file using bun:test framework. Each AC maps to exactly one test named "AC-N: <description>".
 
 Use this structure:
 
@@ -18518,6 +18565,40 @@ Respond with ONLY the TypeScript test code (no markdown code fences, no explanat
   await _generatorPRDDeps.writeFile(join2(options.workdir, "acceptance-refined.json"), refinedJsonContent);
   return { testCode, criteria };
 }
+function buildStrategyInstructions(strategy, framework) {
+  switch (strategy) {
+    case "component": {
+      const fw = framework ?? "ink-testing-library";
+      if (fw === "react") {
+        return `TEST STRATEGY: component (react)
+Import render and screen from @testing-library/react. Render the component and use screen.getByText to assert on output.
+
+`;
+      }
+      return `TEST STRATEGY: component (ink-testing-library)
+Import render from ink-testing-library. Render the component and use lastFrame() to assert on output.
+
+`;
+    }
+    case "cli":
+      return `TEST STRATEGY: cli
+Use Bun.spawn to run the binary. Read stdout and assert on the text output.
+
+`;
+    case "e2e":
+      return `TEST STRATEGY: e2e
+Use fetch() against http://localhost to call the running service. Assert on response body using response.text() or response.json().
+
+`;
+    case "snapshot":
+      return `TEST STRATEGY: snapshot
+Render the component and use toMatchSnapshot() to capture and compare snapshots.
+
+`;
+    default:
+      return "";
+  }
+}
 function parseAcceptanceCriteria(specContent) {
   const criteria = [];
   const lines = specContent.split(`
@@ -21034,7 +21115,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.40.0",
+    version: "0.40.1",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -21098,8 +21179,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("5b23ab2"))
-        return "5b23ab2";
+      if (/^[0-9a-f]{6,10}$/.test("ba3f634"))
+        return "ba3f634";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -22846,7 +22927,9 @@ ${stderr}` };
           refinedCriteria = await _acceptanceSetupDeps.refine(allCriteria, {
             storyId: ctx.prd.userStories[0]?.id ?? "US-001",
             codebaseContext: "",
-            config: ctx.config
+            config: ctx.config,
+            testStrategy: ctx.config.acceptance.testStrategy,
+            testFramework: ctx.config.acceptance.testFramework
           });
         } else {
           refinedCriteria = allCriteria.map((c) => ({
@@ -22863,7 +22946,9 @@ ${stderr}` };
           codebaseContext: "",
           modelTier: ctx.config.acceptance.model ?? "fast",
           modelDef: resolveModel(ctx.config.models[ctx.config.acceptance.model ?? "fast"]),
-          config: ctx.config
+          config: ctx.config,
+          testStrategy: ctx.config.acceptance.testStrategy,
+          testFramework: ctx.config.acceptance.testFramework
         });
         await _acceptanceSetupDeps.writeFile(testPath, result.testCode);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.40.0",
+  "version": "0.40.1",
   "description": "AI Coding Agent Orchestrator — loops until done",
   "type": "module",
   "bin": {

package/src/acceptance/generator.ts

@@ -82,6 +82,8 @@ export async function generateFromPRD(
 
   const criteriaList = refinedCriteria.map((c, i) => `AC-${i + 1}: ${c.refined}`).join("\n");
 
+  const strategyInstructions = buildStrategyInstructions(options.testStrategy, options.testFramework);
+
   const prompt = `You are a test engineer. Generate acceptance tests for the "${options.featureName}" feature based on the refined acceptance criteria below.
 
 CODEBASE CONTEXT:
@@ -90,7 +92,7 @@ ${options.codebaseContext}
 ACCEPTANCE CRITERIA (refined):
 ${criteriaList}
 
-Generate a complete acceptance.test.ts file using bun:test framework. Each AC maps to exactly one test named "AC-N: <description>".
+${strategyInstructions}Generate a complete acceptance.test.ts file using bun:test framework. Each AC maps to exactly one test named "AC-N: <description>".
 
 Use this structure:
 
@@ -127,6 +129,26 @@ Respond with ONLY the TypeScript test code (no markdown code fences, no explanat
   return { testCode, criteria };
 }
 
+function buildStrategyInstructions(strategy?: string, framework?: string): string {
+  switch (strategy) {
+    case "component": {
+      const fw = framework ?? "ink-testing-library";
+      if (fw === "react") {
+        return "TEST STRATEGY: component (react)\nImport render and screen from @testing-library/react. Render the component and use screen.getByText to assert on output.\n\n";
+      }
+      return "TEST STRATEGY: component (ink-testing-library)\nImport render from ink-testing-library. Render the component and use lastFrame() to assert on output.\n\n";
+    }
+    case "cli":
+      return "TEST STRATEGY: cli\nUse Bun.spawn to run the binary. Read stdout and assert on the text output.\n\n";
+    case "e2e":
+      return "TEST STRATEGY: e2e\nUse fetch() against http://localhost to call the running service. Assert on response body using response.text() or response.json().\n\n";
+    case "snapshot":
+      return "TEST STRATEGY: snapshot\nRender the component and use toMatchSnapshot() to capture and compare snapshots.\n\n";
+    default:
+      return "";
+  }
+}
+
 export function parseAcceptanceCriteria(specContent: string): AcceptanceCriterion[] {
   const criteria: AcceptanceCriterion[] = [];
   const lines = specContent.split("\n");

package/src/acceptance/refinement.ts

@@ -22,21 +22,38 @@ export const _refineDeps = {
   adapter: new ClaudeCodeAdapter() as AgentAdapter,
 };
 
+/**
+ * Strategy-specific context for the refinement prompt.
+ */
+export interface RefinementPromptOptions {
+  /** Test strategy — controls strategy-specific prompt instructions */
+  testStrategy?: "unit" | "component" | "cli" | "e2e" | "snapshot";
+  /** Test framework — informs LLM which testing library syntax to use */
+  testFramework?: string;
+}
+
 /**
  * Build the LLM prompt for refining acceptance criteria.
  *
  * @param criteria - Raw AC strings from PRD
  * @param codebaseContext - File tree / dependency context
+ * @param options - Optional strategy/framework context
  * @returns Formatted prompt string
  */
-export function buildRefinementPrompt(criteria: string[], codebaseContext: string): string {
+export function buildRefinementPrompt(
+  criteria: string[],
+  codebaseContext: string,
+  options?: RefinementPromptOptions,
+): string {
   const criteriaList = criteria.map((c, i) => `${i + 1}. ${c}`).join("\n");
+  const strategySection = buildStrategySection(options);
+  const refinedExample = buildRefinedExample(options?.testStrategy);
 
   return `You are an acceptance criteria refinement assistant. Your task is to convert raw acceptance criteria into concrete, machine-verifiable assertions.
 
 CODEBASE CONTEXT:
 ${codebaseContext}
-
+${strategySection}
 ACCEPTANCE CRITERIA TO REFINE:
 ${criteriaList}
 
@@ -51,12 +68,62 @@ Respond with ONLY a JSON array (no markdown code fences):
 
 Rules:
 - "original" must match the input criterion text exactly
-- "refined" must be a concrete assertion (e.g., "Function returns array of length N", "HTTP status 200 returned")
+- "refined" must be a concrete assertion (e.g., ${refinedExample})
 - "testable" is false only if the criterion cannot be automatically verified (e.g., "UX feels responsive", "design looks good")
 - "storyId" leave as empty string — it will be assigned by the caller
 - Respond with ONLY the JSON array`;
 }
 
+/**
+ * Build strategy-specific instructions section for the prompt.
+ */
+function buildStrategySection(options?: RefinementPromptOptions): string {
+  if (!options?.testStrategy) {
+    return "";
+  }
+
+  const framework = options.testFramework ? ` Use ${options.testFramework} testing library syntax.` : "";
+
+  switch (options.testStrategy) {
+    case "component":
+      return `
+TEST STRATEGY: component
+Focus assertions on rendered output visible on screen — text content, visible elements, and screen state.
+Assert what the user sees rendered in the component, not what internal functions produce.${framework}
+`;
+    case "cli":
+      return `
+TEST STRATEGY: cli
+Focus assertions on stdout and stderr text output from the CLI command.
+Assert about terminal output content, exit codes, and standard output/standard error streams.${framework}
+`;
+    case "e2e":
+      return `
+TEST STRATEGY: e2e
+Focus assertions on HTTP response content — status codes, response bodies, and endpoint behavior.
+Assert about HTTP responses, status codes, and API endpoint output.${framework}
+`;
+    default:
+      return framework ? `\nTEST FRAMEWORK: ${options.testFramework}\n` : "";
+  }
+}
+
+/**
+ * Build the "refined" example string based on the test strategy.
+ */
+function buildRefinedExample(testStrategy?: RefinementPromptOptions["testStrategy"]): string {
+  switch (testStrategy) {
+    case "component":
+      return '"Text content visible on screen matches expected", "Rendered output contains expected element"';
+    case "cli":
+      return '"stdout contains expected text", "stderr is empty on success", "exit code is 0"';
+    case "e2e":
+      return '"HTTP status 200 returned", "Response body contains expected field", "Endpoint returns JSON"';
+    default:
+      return '"Array of length N returned", "HTTP status 200 returned"';
+  }
+}
+
 /**
  * Parse the LLM JSON response into RefinedCriterion[].
  *
@@ -105,7 +172,7 @@ export async function refineAcceptanceCriteria(
     return [];
   }
 
-  const { storyId, codebaseContext, config } = context;
+  const { storyId, codebaseContext, config, testStrategy, testFramework } = context;
   const logger = getLogger();
 
   const modelTier = config.acceptance?.model ?? "fast";
@@ -116,7 +183,7 @@ export async function refineAcceptanceCriteria(
   }
 
   const modelDef = resolveModel(modelEntry);
-  const prompt = buildRefinementPrompt(criteria, codebaseContext);
+  const prompt = buildRefinementPrompt(criteria, codebaseContext, { testStrategy, testFramework });
 
   let response: string;
 

package/src/acceptance/templates/cli.ts

@@ -0,0 +1,47 @@
+/**
+ * CLI test template builder
+ *
+ * Generates acceptance test structure for CLI testing strategy.
+ * Uses Bun.spawn to run the binary and asserts on stdout text.
+ */
+
+import type { AcceptanceCriterion } from "../types";
+
+export interface CliTemplateOptions {
+  featureName: string;
+  criteria: AcceptanceCriterion[];
+}
+
+/**
+ * Build CLI test template code for the given criteria.
+ *
+ * @param options - Feature name and criteria list
+ * @returns TypeScript test code string
+ */
+export function buildCliTemplate(options: CliTemplateOptions): string {
+  const { featureName, criteria } = options;
+
+  const tests = criteria
+    .map(
+      (ac) => `  test("${ac.id}: ${ac.text}", async () => {
+    const proc = Bun.spawn(["bun", "run", "src/${featureName}.ts"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [exitCode, stdout] = await Promise.all([
+      proc.exited,
+      new Response(proc.stdout).text(),
+    ]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain(""); // Replace with expected stdout text
+  });`,
+    )
+    .join("\n\n");
+
+  return `import { describe, expect, test } from "bun:test";
+
+describe("${featureName} - Acceptance Tests", () => {
+${tests}
+});
+`;
+}

package/src/acceptance/templates/component.ts

@@ -0,0 +1,78 @@
+/**
+ * Component test template builder
+ *
+ * Generates acceptance test structure for component testing strategy.
+ * Supports ink-testing-library (lastFrame) and react (screen.getByText).
+ */
+
+import type { AcceptanceCriterion } from "../types";
+
+export interface ComponentTemplateOptions {
+  featureName: string;
+  criteria: AcceptanceCriterion[];
+  /** Test framework: 'ink-testing-library' | 'react' */
+  testFramework?: string;
+}
+
+/**
+ * Build component test template code for the given criteria.
+ *
+ * @param options - Feature name, criteria, and test framework
+ * @returns TypeScript test code string
+ */
+export function buildComponentTemplate(options: ComponentTemplateOptions): string {
+  const { featureName, criteria, testFramework = "ink-testing-library" } = options;
+
+  if (testFramework === "react") {
+    return buildReactTemplate(featureName, criteria);
+  }
+
+  return buildInkTemplate(featureName, criteria);
+}
+
+function buildInkTemplate(featureName: string, criteria: AcceptanceCriterion[]): string {
+  const tests = criteria
+    .map(
+      (ac) => `  test("${ac.id}: ${ac.text}", () => {
+    const { lastFrame } = render(<${toPascalCase(featureName)} />);
+    expect(lastFrame()).toContain(""); // Replace with expected output
+  });`,
+    )
+    .join("\n\n");
+
+  return `import { describe, expect, test } from "bun:test";
+import { render } from "ink-testing-library";
+import { ${toPascalCase(featureName)} } from "../src/${featureName}";
+
+describe("${featureName} - Acceptance Tests", () => {
+${tests}
+});
+`;
+}
+
+function buildReactTemplate(featureName: string, criteria: AcceptanceCriterion[]): string {
+  const tests = criteria
+    .map(
+      (ac) => `  test("${ac.id}: ${ac.text}", () => {
+    render(<${toPascalCase(featureName)} />);
+    expect(screen.getByText("")).toBeTruthy(); // Replace with expected text
+  });`,
+    )
+    .join("\n\n");
+
+  return `import { describe, expect, test } from "bun:test";
+import { render, screen } from "@testing-library/react";
+import { ${toPascalCase(featureName)} } from "../src/${featureName}";
+
+describe("${featureName} - Acceptance Tests", () => {
+${tests}
+});
+`;
+}
+
+function toPascalCase(name: string): string {
+  return name
+    .split(/[-_\s]+/)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}

package/src/acceptance/templates/e2e.ts

@@ -0,0 +1,43 @@
+/**
+ * E2E test template builder
+ *
+ * Generates acceptance test structure for end-to-end testing strategy.
+ * Uses fetch() against localhost and asserts on response body.
+ */
+
+import type { AcceptanceCriterion } from "../types";
+
+export interface E2eTemplateOptions {
+  featureName: string;
+  criteria: AcceptanceCriterion[];
+}
+
+const DEFAULT_PORT = 3000;
+
+/**
+ * Build E2E test template code for the given criteria.
+ *
+ * @param options - Feature name and criteria list
+ * @returns TypeScript test code string
+ */
+export function buildE2eTemplate(options: E2eTemplateOptions): string {
+  const { featureName, criteria } = options;
+
+  const tests = criteria
+    .map(
+      (ac) => `  test("${ac.id}: ${ac.text}", async () => {
+    const response = await fetch("http://localhost:${DEFAULT_PORT}/api/${featureName}");
+    expect(response.ok).toBe(true);
+    const body = await response.text();
+    expect(body).toContain(""); // Replace with expected response body
+  });`,
+    )
+    .join("\n\n");
+
+  return `import { describe, expect, test } from "bun:test";
+
+describe("${featureName} - Acceptance Tests", () => {
+${tests}
+});
+`;
+}

package/src/acceptance/templates/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Acceptance Test Template Builders
+ *
+ * One builder per test strategy. The generator selects the appropriate
+ * builder based on the testStrategy option.
+ */
+
+export { buildUnitTemplate } from "./unit";
+export type { UnitTemplateOptions } from "./unit";
+
+export { buildComponentTemplate } from "./component";
+export type { ComponentTemplateOptions } from "./component";
+
+export { buildCliTemplate } from "./cli";
+export type { CliTemplateOptions } from "./cli";
+
+export { buildE2eTemplate } from "./e2e";
+export type { E2eTemplateOptions } from "./e2e";
+
+export { buildSnapshotTemplate } from "./snapshot";
+export type { SnapshotTemplateOptions } from "./snapshot";

package/src/acceptance/templates/snapshot.ts

@@ -0,0 +1,50 @@
+/**
+ * Snapshot test template builder
+ *
+ * Generates acceptance test structure for snapshot testing strategy.
+ * Renders the component and uses toMatchSnapshot() for assertions.
+ */
+
+import type { AcceptanceCriterion } from "../types";
+
+export interface SnapshotTemplateOptions {
+  featureName: string;
+  criteria: AcceptanceCriterion[];
+  /** Test framework: 'ink-testing-library' | 'react' */
+  testFramework?: string;
+}
+
+/**
+ * Build snapshot test template code for the given criteria.
+ *
+ * @param options - Feature name, criteria, and optional test framework
+ * @returns TypeScript test code string
+ */
+export function buildSnapshotTemplate(options: SnapshotTemplateOptions): string {
+  const { featureName, criteria } = options;
+
+  const tests = criteria
+    .map(
+      (ac) => `  test("${ac.id}: ${ac.text}", () => {
+    const { lastFrame } = render(<${toPascalCase(featureName)} />);
+    expect(lastFrame()).toMatchSnapshot();
+  });`,
+    )
+    .join("\n\n");
+
+  return `import { describe, expect, test } from "bun:test";
+import { render } from "ink-testing-library";
+import { ${toPascalCase(featureName)} } from "../src/${featureName}";
+
+describe("${featureName} - Acceptance Tests", () => {
+${tests}
+});
+`;
+}
+
+function toPascalCase(name: string): string {
+  return name
+    .split(/[-_\s]+/)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}

package/src/acceptance/templates/unit.ts

@@ -0,0 +1,48 @@
+/**
+ * Unit test template builder
+ *
+ * Generates acceptance test structure for unit testing strategy:
+ * imports the function under test, calls it, and asserts on the return value.
+ */
+
+import type { AcceptanceCriterion } from "../types";
+
+export interface UnitTemplateOptions {
+  featureName: string;
+  criteria: AcceptanceCriterion[];
+}
+
+/**
+ * Build unit test template code for the given criteria.
+ *
+ * @param options - Feature name and criteria list
+ * @returns TypeScript test code string
+ */
+export function buildUnitTemplate(options: UnitTemplateOptions): string {
+  const { featureName, criteria } = options;
+
+  const tests = criteria
+    .map(
+      (ac) => `  test("${ac.id}: ${ac.text}", async () => {
+    // TODO: import and call the function under test
+    expect(true).toBe(true); // Replace with real assertion
+  });`,
+    )
+    .join("\n\n");
+
+  return `import { describe, expect, test } from "bun:test";
+import { ${toCamelCase(featureName)} } from "../src/${toKebabCase(featureName)}";
+
+describe("${featureName} - Acceptance Tests", () => {
+${tests}
+});
+`;
+}
+
+function toCamelCase(name: string): string {
+  return name.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase());
+}
+
+function toKebabCase(name: string): string {
+  return name.toLowerCase().replace(/\s+/g, "-");
+}

package/src/acceptance/types.ts

@@ -4,7 +4,7 @@
  * Types for generating acceptance tests from spec.md acceptance criteria.
  */
 
-import type { ModelDef, ModelTier, NaxConfig } from "../config/schema";
+import type { AcceptanceTestStrategy, ModelDef, ModelTier, NaxConfig } from "../config/schema";
 
 /**
  * A single refined acceptance criterion produced by the refinement module.
@@ -30,6 +30,10 @@ export interface RefinementContext {
   codebaseContext: string;
   /** Global config — model tier resolved from config.acceptance.model */
   config: NaxConfig;
+  /** Test strategy — controls strategy-specific prompt instructions */
+  testStrategy?: AcceptanceTestStrategy;
+  /** Test framework — informs LLM which testing library syntax to use */
+  testFramework?: string;
 }
 
 /**
@@ -84,6 +88,10 @@ export interface GenerateFromPRDOptions {
   modelDef: ModelDef;
   /** Global config for quality settings */
   config: NaxConfig;
+  /** Test strategy to use for template selection (default: 'unit') */
+  testStrategy?: AcceptanceTestStrategy;
+  /** Test framework for component/snapshot strategies (e.g. 'ink-testing-library', 'react') */
+  testFramework?: string;
 }
 
 export interface GenerateAcceptanceTestsOptions {

package/src/cli/init-detect.ts

@@ -5,12 +5,74 @@
  * for nax/config.json.
  */
 
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
 /** Detected project runtime */
 export type Runtime = "bun" | "node" | "unknown";
 
+/** Detected UI framework */
+export type UIFramework = "ink" | "react" | "vue" | "svelte";
+
+/** Full stack info including UI framework and bin detection */
+export interface StackInfo extends ProjectStack {
+  uiFramework?: UIFramework;
+  hasBin?: boolean;
+}
+
+/** Shape of a parsed package.json for detection purposes */
+interface PackageJson {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  bin?: Record<string, string> | string;
+}
+
+function readPackageJson(projectRoot: string): PackageJson | undefined {
+  const pkgPath = join(projectRoot, "package.json");
+  if (!existsSync(pkgPath)) return undefined;
+  try {
+    return JSON.parse(readFileSync(pkgPath, "utf-8")) as PackageJson;
+  } catch {
+    return undefined;
+  }
+}
+
+function allDeps(pkg: PackageJson): Record<string, string> {
+  return {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+    ...pkg.peerDependencies,
+  };
+}
+
+function detectUIFramework(pkg: PackageJson): UIFramework | undefined {
+  const deps = allDeps(pkg);
+  if ("ink" in deps) return "ink";
+  if ("react" in deps || "next" in deps) return "react";
+  if ("vue" in deps || "nuxt" in deps) return "vue";
+  if ("svelte" in deps || "@sveltejs/kit" in deps) return "svelte";
+  return undefined;
+}
+
+function detectHasBin(pkg: PackageJson): boolean {
+  return pkg.bin !== undefined;
+}
+
+/**
+ * Detect the project stack including UI framework from package.json.
+ */
+export function detectStack(projectRoot: string): StackInfo {
+  const base = detectProjectStack(projectRoot);
+  const pkg = readPackageJson(projectRoot);
+  if (!pkg) return base;
+  return {
+    ...base,
+    uiFramework: detectUIFramework(pkg),
+    hasBin: detectHasBin(pkg) || undefined,
+  };
+}
+
 /** Detected project language */
 export type Language = "typescript" | "python" | "rust" | "go" | "unknown";
 
@@ -146,24 +208,48 @@ function isStackDetected(stack: ProjectStack): boolean {
   return stack.runtime !== "unknown" || stack.language !== "unknown";
 }
 
+/** Build the acceptance config section from StackInfo, or undefined if not applicable. */
+function buildAcceptanceConfig(stack: StackInfo): { testStrategy: string; testFramework?: string } | undefined {
+  if (stack.uiFramework === "ink") {
+    return { testStrategy: "component", testFramework: "ink-testing-library" };
+  }
+  if (stack.uiFramework === "react") {
+    return { testStrategy: "component", testFramework: "@testing-library/react" };
+  }
+  if (stack.uiFramework === "vue") {
+    return { testStrategy: "component", testFramework: "@testing-library/vue" };
+  }
+  if (stack.uiFramework === "svelte") {
+    return { testStrategy: "component", testFramework: "@testing-library/svelte" };
+  }
+  if (stack.hasBin) {
+    const testFramework = stack.runtime === "bun" ? "bun:test" : "jest";
+    return { testStrategy: "cli", testFramework };
+  }
+  return undefined;
+}
+
 /**
  * Build the full init config object from a detected project stack.
  * Falls back to minimal config when stack is undetected.
  */
-export function buildInitConfig(stack: ProjectStack): object {
+export function buildInitConfig(stack: ProjectStack | StackInfo): object {
+  const stackInfo = stack as StackInfo;
+  const acceptance = buildAcceptanceConfig(stackInfo);
+
   if (!isStackDetected(stack)) {
-    return { version: 1 };
+    return acceptance ? { version: 1, acceptance } : { version: 1 };
   }
 
   const commands = buildQualityCommands(stack);
   const hasCommands = Object.keys(commands).length > 0;
 
-  if (!hasCommands) {
+  if (!hasCommands && !acceptance) {
     return { version: 1 };
   }
 
-  return {
-    version: 1,
-    quality: { commands },
-  };
+  const config: Record<string, unknown> = { version: 1 };
+  if (hasCommands) config.quality = { commands };
+  if (acceptance) config.acceptance = acceptance;
+  return config;
 }

package/src/cli/init.ts

@@ -10,7 +10,7 @@ import { join } from "node:path";
 import { globalConfigDir, projectConfigDir } from "../config/paths";
 import { getLogger } from "../logger";
 import { initContext } from "./init-context";
-import { buildInitConfig, detectProjectStack } from "./init-detect";
+import { buildInitConfig, detectStack } from "./init-detect";
 import type { ProjectStack } from "./init-detect";
 import { promptsInitCommand } from "./prompts";
 
@@ -183,7 +183,7 @@ export async function initProject(projectRoot: string, options?: InitProjectOpti
   }
 
   // Detect project stack and build config
-  const stack = detectProjectStack(projectRoot);
+  const stack = detectStack(projectRoot);
   const projectConfig = buildInitConfig(stack);
   logger.info("init", "Detected project stack", {
     runtime: stack.runtime,

package/src/config/index.ts

@@ -14,7 +14,7 @@ export type {
   TierConfig,
   RectificationConfig,
 } from "./schema";
-export { DEFAULT_CONFIG, resolveModel, NaxConfigSchema } from "./schema";
+export { DEFAULT_CONFIG, resolveModel, NaxConfigSchema, AcceptanceConfigSchema } from "./schema";
 export { loadConfig, findProjectDir, globalConfigPath } from "./loader";
 export { validateConfig, type ValidationResult } from "./validate"; // @deprecated: Use NaxConfigSchema.safeParse() instead
 export { validateDirectory, validateFilePath, isWithinDirectory, MAX_DIRECTORY_DEPTH } from "./path-security";

package/src/config/runtime-types.ts

@@ -228,6 +228,9 @@ export interface PlanConfig {
   outputPath: string;
 }
 
+/** Valid test strategy values for acceptance testing */
+export type AcceptanceTestStrategy = "unit" | "component" | "cli" | "e2e" | "snapshot";
+
 /** Acceptance validation config */
 export interface AcceptanceConfig {
   /** Enable acceptance test generation and validation */
@@ -244,6 +247,10 @@ export interface AcceptanceConfig {
   refinement: boolean;
   /** Whether to run RED gate check after generating acceptance tests (default: true) */
   redGate: boolean;
+  /** Test strategy for acceptance tests (default: auto-detect) */
+  testStrategy?: AcceptanceTestStrategy;
+  /** Test framework for acceptance tests (default: auto-detect) */
+  testFramework?: string;
 }
 
 /** Optimizer config (v0.10) */

package/src/config/schema.ts

@@ -30,6 +30,7 @@ export type {
   ReviewConfig,
   PlanConfig,
   AcceptanceConfig,
+  AcceptanceTestStrategy,
   OptimizerConfig,
   PluginConfigEntry,
   HooksConfig,
@@ -52,7 +53,7 @@ export type {
 export { resolveModel } from "./types";
 
 // Zod schemas
-export { NaxConfigSchema } from "./schemas";
+export { NaxConfigSchema, AcceptanceConfigSchema } from "./schemas";
 
 // Default config
 export { DEFAULT_CONFIG } from "./defaults";

package/src/config/schemas.ts

@@ -210,7 +210,7 @@ const PlanConfigSchema = z.object({
   outputPath: z.string().min(1, "plan.outputPath must be non-empty"),
 });
 
-const AcceptanceConfigSchema = z.object({
+export const AcceptanceConfigSchema = z.object({
   enabled: z.boolean(),
   maxRetries: z.number().int().nonnegative(),
   generateTests: z.boolean(),
@@ -218,6 +218,8 @@ const AcceptanceConfigSchema = z.object({
   model: z.enum(["fast", "balanced", "powerful"]).default("fast"),
   refinement: z.boolean().default(true),
   redGate: z.boolean().default(true),
+  testStrategy: z.enum(["unit", "component", "cli", "e2e", "snapshot"]).optional(),
+  testFramework: z.string().min(1, "acceptance.testFramework must be non-empty").optional(),
 });
 
 const TestCoverageConfigSchema = z.object({

package/src/config/types.ts

@@ -24,6 +24,7 @@ export { resolveModel } from "./schema-types";
 // Runtime types
 export type {
   AcceptanceConfig,
+  AcceptanceTestStrategy,
   AnalyzeConfig,
   AutoModeConfig,
   ConstitutionConfig,

package/src/pipeline/stages/acceptance-setup.ts

@@ -89,6 +89,8 @@ export const acceptanceSetupStage: PipelineStage = {
           storyId: ctx.prd.userStories[0]?.id ?? "US-001",
           codebaseContext: "",
           config: ctx.config,
+          testStrategy: ctx.config.acceptance.testStrategy,
+          testFramework: ctx.config.acceptance.testFramework,
         });
       } else {
         refinedCriteria = allCriteria.map((c) => ({
@@ -108,6 +110,8 @@ export const acceptanceSetupStage: PipelineStage = {
         modelTier: ctx.config.acceptance.model ?? "fast",
         modelDef: resolveModel(ctx.config.models[ctx.config.acceptance.model ?? "fast"]),
         config: ctx.config,
+        testStrategy: ctx.config.acceptance.testStrategy,
+        testFramework: ctx.config.acceptance.testFramework,
       });
 
       await _acceptanceSetupDeps.writeFile(testPath, result.testCode);