@nathapp/nax 0.18.1

package/src/context/generator.ts

@@ -0,0 +1,129 @@
+/**
+ * Context Generator Orchestrator (v0.16.1)
+ *
+ * Generates agent-specific config files from nax/context.md + auto-injected metadata.
+ * Replaces the old constitution generator.
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { NaxConfig } from "../config";
+import { validateFilePath } from "../config/path-security";
+import { aiderGenerator } from "./generators/aider";
+import { claudeGenerator } from "./generators/claude";
+import { cursorGenerator } from "./generators/cursor";
+import { opencodeGenerator } from "./generators/opencode";
+import { windsurfGenerator } from "./generators/windsurf";
+import { buildProjectMetadata } from "./injector";
+import type { AgentContextGenerator, AgentType, ContextContent, GeneratorMap } from "./types";
+
+/** Generator registry */
+const GENERATORS: GeneratorMap = {
+  claude: claudeGenerator,
+  opencode: opencodeGenerator,
+  cursor: cursorGenerator,
+  windsurf: windsurfGenerator,
+  aider: aiderGenerator,
+};
+
+/** Generation result for a single agent */
+export interface GenerationResult {
+  agent: AgentType;
+  outputFile: string;
+  content: string;
+  written: boolean;
+  error?: string;
+}
+
+/** Generate options */
+export interface GenerateOptions {
+  /** Path to nax/context.md (default: <workdir>/nax/context.md) */
+  contextPath: string;
+  /** Output directory (default: project root) */
+  outputDir: string;
+  /** Working directory for metadata injection */
+  workdir: string;
+  /** Dry run mode */
+  dryRun?: boolean;
+  /** Specific agent (default: all) */
+  agent?: AgentType;
+  /** Auto-inject project metadata (default: true) */
+  autoInject?: boolean;
+}
+
+/**
+ * Load context content and optionally inject project metadata.
+ */
+async function loadContextContent(options: GenerateOptions, config: NaxConfig): Promise<ContextContent> {
+  if (!existsSync(options.contextPath)) {
+    throw new Error(`Context file not found: ${options.contextPath}`);
+  }
+
+  const file = Bun.file(options.contextPath);
+  const markdown = await file.text();
+
+  const autoInject = options.autoInject ?? true;
+  const metadata = autoInject ? await buildProjectMetadata(options.workdir, config) : undefined;
+
+  return { markdown, metadata };
+}
+
+/**
+ * Generate config for a specific agent.
+ */
+async function generateFor(agent: AgentType, options: GenerateOptions, config: NaxConfig): Promise<GenerationResult> {
+  const generator = GENERATORS[agent];
+  if (!generator) {
+    return { agent, outputFile: "", content: "", written: false, error: `Unknown agent: ${agent}` };
+  }
+
+  try {
+    const context = await loadContextContent(options, config);
+    const content = generator.generate(context);
+    const outputPath = join(options.outputDir, generator.outputFile);
+
+    validateFilePath(outputPath, options.outputDir);
+
+    if (!options.dryRun) {
+      await Bun.write(outputPath, content);
+    }
+
+    return { agent, outputFile: generator.outputFile, content, written: !options.dryRun };
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    return { agent, outputFile: generator.outputFile, content: "", written: false, error };
+  }
+}
+
+/**
+ * Generate configs for all agents.
+ */
+async function generateAll(options: GenerateOptions, config: NaxConfig): Promise<GenerationResult[]> {
+  // Load context once and share across generators
+  const context = await loadContextContent(options, config);
+
+  const results: GenerationResult[] = [];
+
+  for (const [agentKey, generator] of Object.entries(GENERATORS) as [AgentType, AgentContextGenerator][]) {
+    try {
+      const content = generator.generate(context);
+      const outputPath = join(options.outputDir, generator.outputFile);
+
+      validateFilePath(outputPath, options.outputDir);
+
+      if (!options.dryRun) {
+        await Bun.write(outputPath, content);
+      }
+
+      results.push({ agent: agentKey, outputFile: generator.outputFile, content, written: !options.dryRun });
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      results.push({ agent: agentKey, outputFile: generator.outputFile, content: "", written: false, error });
+    }
+  }
+
+  return results;
+}
+
+export { generateFor, generateAll };
+export type { AgentType };

package/src/context/generators/aider.ts

@@ -0,0 +1,34 @@
+/**
+ * Aider Config Generator (v0.16.1)
+ *
+ * Generates .aider.conf.yml from nax/context.md + auto-injected metadata.
+ */
+
+import { formatMetadataSection } from "../injector";
+import type { AgentContextGenerator, ContextContent } from "../types";
+
+function generateAiderConfig(context: ContextContent): string {
+  const header = `# Aider Configuration
+# Auto-generated from nax/context.md — run \`nax generate\` to regenerate.
+# DO NOT EDIT MANUALLY
+
+# Project instructions
+instructions: |
+`;
+
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  const combined = metaSection + context.markdown;
+
+  const indented = combined
+    .split("\n")
+    .map((line) => `  ${line}`)
+    .join("\n");
+
+  return `${header}${indented}\n`;
+}
+
+export const aiderGenerator: AgentContextGenerator = {
+  name: "aider",
+  outputFile: ".aider.conf.yml",
+  generate: generateAiderConfig,
+};

package/src/context/generators/claude.ts

@@ -0,0 +1,28 @@
+/**
+ * Claude Code Config Generator (v0.16.1)
+ *
+ * Generates CLAUDE.md from nax/context.md + auto-injected metadata.
+ */
+
+import { formatMetadataSection } from "../injector";
+import type { AgentContextGenerator, ContextContent } from "../types";
+
+function generateClaudeConfig(context: ContextContent): string {
+  const header = `# Project Context
+
+This file is auto-generated from \`nax/context.md\`.
+DO NOT EDIT MANUALLY — run \`nax generate\` to regenerate.
+
+---
+
+`;
+
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  return header + metaSection + context.markdown;
+}
+
+export const claudeGenerator: AgentContextGenerator = {
+  name: "claude",
+  outputFile: "CLAUDE.md",
+  generate: generateClaudeConfig,
+};

package/src/context/generators/cursor.ts

@@ -0,0 +1,28 @@
+/**
+ * Cursor Rules Generator (v0.16.1)
+ *
+ * Generates .cursorrules from nax/context.md + auto-injected metadata.
+ */
+
+import { formatMetadataSection } from "../injector";
+import type { AgentContextGenerator, ContextContent } from "../types";
+
+function generateCursorRules(context: ContextContent): string {
+  const header = `# Project Rules
+
+Auto-generated from nax/context.md — run \`nax generate\` to regenerate.
+DO NOT EDIT MANUALLY
+
+---
+
+`;
+
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  return header + metaSection + context.markdown;
+}
+
+export const cursorGenerator: AgentContextGenerator = {
+  name: "cursor",
+  outputFile: ".cursorrules",
+  generate: generateCursorRules,
+};

package/src/context/generators/opencode.ts

@@ -0,0 +1,30 @@
+/**
+ * OpenCode Config Generator (v0.16.1)
+ *
+ * Generates AGENTS.md from nax/context.md + auto-injected metadata.
+ */
+
+import { formatMetadataSection } from "../injector";
+import type { AgentContextGenerator, ContextContent } from "../types";
+
+function generateOpencodeConfig(context: ContextContent): string {
+  const header = `# Agent Instructions
+
+This file is auto-generated from \`nax/context.md\`.
+DO NOT EDIT MANUALLY — run \`nax generate\` to regenerate.
+
+These instructions apply to all AI coding agents in this project.
+
+---
+
+`;
+
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  return header + metaSection + context.markdown;
+}
+
+export const opencodeGenerator: AgentContextGenerator = {
+  name: "opencode",
+  outputFile: "AGENTS.md",
+  generate: generateOpencodeConfig,
+};

package/src/context/generators/windsurf.ts

@@ -0,0 +1,28 @@
+/**
+ * Windsurf Rules Generator (v0.16.1)
+ *
+ * Generates .windsurfrules from nax/context.md + auto-injected metadata.
+ */
+
+import { formatMetadataSection } from "../injector";
+import type { AgentContextGenerator, ContextContent } from "../types";
+
+function generateWindsurfRules(context: ContextContent): string {
+  const header = `# Windsurf Project Rules
+
+Auto-generated from nax/context.md — run \`nax generate\` to regenerate.
+DO NOT EDIT MANUALLY
+
+---
+
+`;
+
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  return header + metaSection + context.markdown;
+}
+
+export const windsurfGenerator: AgentContextGenerator = {
+  name: "windsurf",
+  outputFile: ".windsurfrules",
+  generate: generateWindsurfRules,
+};

package/src/context/greenfield.ts

@@ -0,0 +1,114 @@
+/**
+ * Greenfield Detection
+ *
+ * Detects whether a story is "greenfield" (no existing test files in workdir).
+ * Greenfield stories skip TDD and use test-after strategy to prevent test-writer
+ * from producing empty test files (BUG-010).
+ */
+
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { UserStory } from "../prd/types";
+
+/**
+ * Recursively scan directory for test files.
+ * Ignores node_modules, dist, build, .next directories.
+ * Throws error if root directory is unreadable.
+ */
+async function scanForTestFiles(dir: string, testPattern: RegExp, isRootCall = true): Promise<string[]> {
+  const results: string[] = [];
+  const ignoreDirs = new Set(["node_modules", "dist", "build", ".next", ".git"]);
+
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Skip ignored directories
+        if (ignoreDirs.has(entry.name)) continue;
+
+        // Recursively scan subdirectories (not root call)
+        const subResults = await scanForTestFiles(fullPath, testPattern, false);
+        results.push(...subResults);
+      } else if (entry.isFile()) {
+        // Check if file matches test pattern
+        if (testPattern.test(entry.name)) {
+          results.push(fullPath);
+        }
+      }
+    }
+  } catch (error) {
+    // If this is the root call and we can't read it, propagate the error
+    if (isRootCall) {
+      throw error;
+    }
+    // Otherwise, ignore errors from unreadable subdirectories
+  }
+
+  return results;
+}
+
+/**
+ * Convert simple glob pattern to regex.
+ * Supports:
+ * - ** (any directory depth)
+ * - * (any characters except /)
+ * - {a,b,c} (alternatives)
+ */
+function globToRegex(pattern: string): RegExp {
+  // Extract filename pattern from glob (everything after last /)
+  const parts = pattern.split("/");
+  const filePattern = parts[parts.length - 1];
+
+  // Convert glob syntax to regex
+  const regexStr = filePattern
+    .replace(/\./g, "\\.") // Escape dots
+    .replace(/\*/g, "[^/]*") // * = any chars except /
+    .replace(/\{([^}]+)\}/g, (_, group) => `(${group.replace(/,/g, "|")})`) // {a,b} = (a|b)
+    .replace(/\\\.\\\*/g, "\\.[^/]*"); // Fix escaped .* back to .\*
+
+  return new RegExp(`${regexStr}$`);
+}
+
+/**
+ * Detect if a story is greenfield based on test file presence in workdir.
+ *
+ * A story is greenfield if:
+ * - No test files exist matching the test pattern in the working directory
+ *
+ * This prevents the TDD test-writer from struggling to create tests when there are
+ * no existing test examples to follow.
+ *
+ * @param story - User story to check
+ * @param workdir - Working directory to scan for test files
+ * @param testPattern - Glob pattern for test files (default: "**\/*.{test,spec}.{ts,js,tsx,jsx}")
+ * @returns true if no test files exist (greenfield), false otherwise
+ *
+ * @example
+ * ```ts
+ * // Empty project with no tests
+ * const isGreenfield = await isGreenfieldStory(story, "/path/to/project");
+ * // => true
+ *
+ * // Project with existing test files
+ * const isGreenfield = await isGreenfieldStory(story, "/path/to/project");
+ * // => false
+ * ```
+ */
+export async function isGreenfieldStory(
+  story: UserStory,
+  workdir: string,
+  testPattern = "**/*.{test,spec}.{ts,js,tsx,jsx}",
+): Promise<boolean> {
+  try {
+    const regex = globToRegex(testPattern);
+    const testFiles = await scanForTestFiles(workdir, regex);
+    return testFiles.length === 0;
+  } catch (error) {
+    // If scan fails completely (e.g., workdir doesn't exist), assume not greenfield (safe fallback)
+    // This prevents skipping TDD when we can't determine the actual state
+    return false;
+  }
+}

package/src/context/index.ts

@@ -0,0 +1,33 @@
+/**
+ * Context builder module for story-scoped prompt optimization
+ */
+
+export type { ContextElement, ContextBudget, StoryContext, BuiltContext } from "./types";
+
+export {
+  estimateTokens,
+  createStoryContext,
+  createDependencyContext,
+  createErrorContext,
+  createProgressContext,
+  createFileContext,
+  sortContextElements,
+  buildContext,
+  createTestCoverageContext,
+  formatContextAsMarkdown,
+} from "./builder";
+
+export {
+  generateTestCoverageSummary,
+  scanTestFiles,
+  extractTestStructure,
+  formatTestSummary,
+  truncateToTokenBudget,
+  type TestScanOptions,
+  type TestScanResult,
+  type TestFileInfo,
+  type DescribeBlock,
+  type TestSummaryDetail,
+} from "./test-scanner";
+
+export { autoDetectContextFiles, extractKeywords, type AutoDetectOptions } from "./auto-detect";