@nathapp/nax 0.50.3 → 0.51.2

package/src/context/greenfield.ts

@@ -1,114 +0,0 @@
-/**
- * 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}$`); // nosemgrep: detect-non-literal-regexp — pattern from internal .gitignore, not user input
-}
-
-/**
- * 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

@@ -1,34 +0,0 @@
-/**
- * Context builder module for story-scoped prompt optimization
- */
-
-export type { ContextElement, ContextBudget, StoryContext, BuiltContext } from "./types";
-
-export {
-  createStoryContext,
-  createDependencyContext,
-  createErrorContext,
-  createProgressContext,
-  createFileContext,
-  sortContextElements,
-  buildContext,
-  createTestCoverageContext,
-  formatContextAsMarkdown,
-} from "./builder";
-
-export { estimateTokens } from "../optimizer/types";
-
-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";

package/src/context/injector.ts

@@ -1,279 +0,0 @@
-/**
- * Project Metadata Auto-Injector (v0.16.1)
- *
- * Detects project language/stack and injects metadata into agent configs.
- * Supports: Node.js/Bun (package.json), Go (go.mod), Rust (Cargo.toml),
- *           Python (pyproject.toml / requirements.txt), PHP (composer.json),
- *           Ruby (Gemfile), Java/Kotlin (pom.xml / build.gradle).
- */
-
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import type { NaxConfig } from "../config";
-import type { ProjectMetadata } from "./types";
-
-/** Notable Node.js dependency keywords */
-const NOTABLE_NODE_DEPS = [
-  "@nestjs",
-  "express",
-  "fastify",
-  "koa",
-  "hono",
-  "next",
-  "nuxt",
-  "react",
-  "vue",
-  "svelte",
-  "solid",
-  "prisma",
-  "typeorm",
-  "mongoose",
-  "drizzle",
-  "sequelize",
-  "jest",
-  "vitest",
-  "mocha",
-  "bun",
-  "zod",
-  "typescript",
-  "graphql",
-  "trpc",
-  "bull",
-  "ioredis",
-];
-
-// ─── Language detectors ──────────────────────────────────────────────────────
-
-/** Node.js / Bun: read package.json */
-async function detectNode(workdir: string): Promise<{ name?: string; lang: string; dependencies: string[] } | null> {
-  const pkgPath = join(workdir, "package.json");
-  if (!existsSync(pkgPath)) return null;
-
-  try {
-    const file = Bun.file(pkgPath);
-    const pkg = await file.json();
-    const allDeps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
-    const notable = [
-      ...new Set(
-        Object.keys(allDeps).filter((dep) =>
-          NOTABLE_NODE_DEPS.some((kw) => dep === kw || dep.startsWith(`${kw}/`) || dep.includes(kw)),
-        ),
-      ),
-    ].slice(0, 10);
-    const lang = pkg.devDependencies?.typescript || pkg.dependencies?.typescript ? "TypeScript" : "JavaScript";
-    return { name: pkg.name, lang, dependencies: notable };
-  } catch {
-    return null;
-  }
-}
-
-/** Go: read go.mod for module name + direct dependencies */
-async function detectGo(workdir: string): Promise<{ name?: string; lang: string; dependencies: string[] } | null> {
-  const goMod = join(workdir, "go.mod");
-  if (!existsSync(goMod)) return null;
-
-  try {
-    const content = await Bun.file(goMod).text();
-    const moduleMatch = content.match(/^module\s+(\S+)/m);
-    const name = moduleMatch?.[1];
-
-    // Extract require block entries (direct deps, not indirect)
-    const requires: string[] = [];
-    const requireBlock = content.match(/require\s*\(([^)]+)\)/s)?.[1] ?? "";
-    for (const line of requireBlock.split("\n")) {
-      const trimmed = line.trim();
-      if (trimmed && !trimmed.startsWith("//") && !trimmed.includes("// indirect")) {
-        const dep = trimmed.split(/\s+/)[0];
-        if (dep) requires.push(dep.split("/").slice(-1)[0]); // last segment only
-      }
-    }
-
-    return { name, lang: "Go", dependencies: requires.slice(0, 10) };
-  } catch {
-    return null;
-  }
-}
-
-/** Rust: read Cargo.toml for package name + dependencies */
-async function detectRust(workdir: string): Promise<{ name?: string; lang: string; dependencies: string[] } | null> {
-  const cargoPath = join(workdir, "Cargo.toml");
-  if (!existsSync(cargoPath)) return null;
-
-  try {
-    const content = await Bun.file(cargoPath).text();
-    const nameMatch = content.match(/^\[package\][^[]*name\s*=\s*"([^"]+)"/ms);
-    const name = nameMatch?.[1];
-
-    // Extract [dependencies] section keys
-    const depsSection = content.match(/^\[dependencies\]([^[]*)/ms)?.[1] ?? "";
-    const deps = depsSection
-      .split("\n")
-      .map((l) => l.split("=")[0].trim())
-      .filter((l) => l && !l.startsWith("#"))
-      .slice(0, 10);
-
-    return { name, lang: "Rust", dependencies: deps };
-  } catch {
-    return null;
-  }
-}
-
-/** Python: read pyproject.toml or requirements.txt */
-async function detectPython(workdir: string): Promise<{ name?: string; lang: string; dependencies: string[] } | null> {
-  const pyproject = join(workdir, "pyproject.toml");
-  const requirements = join(workdir, "requirements.txt");
-
-  if (!existsSync(pyproject) && !existsSync(requirements)) return null;
-
-  try {
-    if (existsSync(pyproject)) {
-      const content = await Bun.file(pyproject).text();
-      const nameMatch = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
-      const depsSection = content.match(/^\[project\][^[]*dependencies\s*=\s*\[([^\]]*)\]/ms)?.[1] ?? "";
-      const deps = depsSection
-        .split(",")
-        .map((d) => d.trim().replace(/["'\s>=<!^~].*/g, ""))
-        .filter(Boolean)
-        .slice(0, 10);
-      return { name: nameMatch?.[1], lang: "Python", dependencies: deps };
-    }
-
-    // Fallback: requirements.txt
-    const lines = (await Bun.file(requirements).text())
-      .split("\n")
-      .map((l) => l.split(/[>=<!]/)[0].trim())
-      .filter((l) => l && !l.startsWith("#"))
-      .slice(0, 10);
-    return { lang: "Python", dependencies: lines };
-  } catch {
-    return null;
-  }
-}
-
-/** PHP: read composer.json */
-async function detectPhp(workdir: string): Promise<{ name?: string; lang: string; dependencies: string[] } | null> {
-  const composerPath = join(workdir, "composer.json");
-  if (!existsSync(composerPath)) return null;
-
-  try {
-    const file = Bun.file(composerPath);
-    const composer = await file.json();
-    const deps = Object.keys({ ...(composer.require ?? {}), ...(composer["require-dev"] ?? {}) })
-      .filter((d) => d !== "php")
-      .map((d) => d.split("/").pop() ?? d)
-      .slice(0, 10);
-    return { name: composer.name, lang: "PHP", dependencies: deps };
-  } catch {
-    return null;
-  }
-}
-
-/** Ruby: read Gemfile */
-async function detectRuby(workdir: string): Promise<{ name?: string; lang: string; dependencies: string[] } | null> {
-  const gemfile = join(workdir, "Gemfile");
-  if (!existsSync(gemfile)) return null;
-
-  try {
-    const content = await Bun.file(gemfile).text();
-    const gems = [...content.matchAll(/^\s*gem\s+['"]([^'"]+)['"]/gm)].map((m) => m[1]).slice(0, 10);
-    return { lang: "Ruby", dependencies: gems };
-  } catch {
-    return null;
-  }
-}
-
-/** Java/Kotlin: detect from pom.xml or build.gradle */
-async function detectJvm(workdir: string): Promise<{ name?: string; lang: string; dependencies: string[] } | null> {
-  const pom = join(workdir, "pom.xml");
-  const gradle = join(workdir, "build.gradle");
-  const gradleKts = join(workdir, "build.gradle.kts");
-
-  if (!existsSync(pom) && !existsSync(gradle) && !existsSync(gradleKts)) return null;
-
-  try {
-    if (existsSync(pom)) {
-      const content = await Bun.file(pom).text();
-      const nameMatch = content.match(/<artifactId>([^<]+)<\/artifactId>/);
-      const deps = [...content.matchAll(/<artifactId>([^<]+)<\/artifactId>/g)]
-        .map((m) => m[1])
-        .filter((d) => d !== nameMatch?.[1])
-        .slice(0, 10);
-      const lang = existsSync(join(workdir, "src/main/kotlin")) ? "Kotlin" : "Java";
-      return { name: nameMatch?.[1], lang, dependencies: deps };
-    }
-
-    const gradleFile = existsSync(gradleKts) ? gradleKts : gradle;
-    const content = await Bun.file(gradleFile).text();
-    const lang = gradleFile.endsWith(".kts") ? "Kotlin" : "Java";
-    const deps = [...content.matchAll(/implementation[^'"]*['"]([^:'"]+:[^:'"]+)[^'"]*['"]/g)]
-      .map((m) => m[1].split(":").pop() ?? m[1])
-      .slice(0, 10);
-    return { lang, dependencies: deps };
-  } catch {
-    return null;
-  }
-}
-
-// ─── Main ────────────────────────────────────────────────────────────────────
-
-/**
- * Detect project language and build metadata.
- * Runs all detectors; first match wins (Node checked last to avoid false positives in polyglot repos).
- */
-export async function buildProjectMetadata(workdir: string, config: NaxConfig): Promise<ProjectMetadata> {
-  // Priority: Go > Rust > Python > PHP > Ruby > JVM > Node
-  const detected =
-    (await detectGo(workdir)) ??
-    (await detectRust(workdir)) ??
-    (await detectPython(workdir)) ??
-    (await detectPhp(workdir)) ??
-    (await detectRuby(workdir)) ??
-    (await detectJvm(workdir)) ??
-    (await detectNode(workdir));
-
-  return {
-    name: detected?.name,
-    language: detected?.lang,
-    dependencies: detected?.dependencies ?? [],
-    testCommand: config.execution?.testCommand ?? undefined,
-    lintCommand: config.execution?.lintCommand ?? undefined,
-    typecheckCommand: config.execution?.typecheckCommand ?? undefined,
-  };
-}
-
-/**
- * Format metadata as a markdown section for injection into agent configs.
- */
-export function formatMetadataSection(metadata: ProjectMetadata): string {
-  const lines: string[] = ["## Project Metadata", "", "> Auto-injected by `nax generate`", ""];
-
-  if (metadata.name) {
-    lines.push(`**Project:** \`${metadata.name}\``);
-    lines.push("");
-  }
-
-  if (metadata.language) {
-    lines.push(`**Language:** ${metadata.language}`);
-    lines.push("");
-  }
-
-  if (metadata.dependencies.length > 0) {
-    lines.push(`**Key dependencies:** ${metadata.dependencies.join(", ")}`);
-    lines.push("");
-  }
-
-  const commands: string[] = [];
-  if (metadata.testCommand) commands.push(`test: \`${metadata.testCommand}\``);
-  if (metadata.lintCommand) commands.push(`lint: \`${metadata.lintCommand}\``);
-  if (metadata.typecheckCommand) commands.push(`typecheck: \`${metadata.typecheckCommand}\``);
-
-  if (commands.length > 0) {
-    lines.push(`**Commands:** ${commands.join(" | ")}`);
-    lines.push("");
-  }
-
-  lines.push("---");
-  lines.push("");
-
-  return lines.join("\n");
-}

package/src/context/parent-context.ts

@@ -1,39 +0,0 @@
-/**
- * Parent output file resolution for context chaining (ENH-005).
- *
- * When a story has dependencies, its parent stories' outputFiles are injected
- * as additional contextFiles so agents have targeted context from prior work.
- */
-
-import type { UserStory } from "../prd/types";
-
-const MAX_PARENT_FILES = 10;
-
-const NOISE_PATTERNS = [
-  /\.test\.(ts|js|tsx|jsx)$/,
-  /\.spec\.(ts|js|tsx|jsx)$/,
-  /package-lock\.json$/,
-  /bun\.lockb?$/,
-  /\.gitignore$/,
-  /^nax\//,
-];
-
-/**
- * Get output files from direct parent stories (dependencies[]).
- * Only direct parents — no transitive resolution (keep simple, extend later).
- * Returns deduped list, filtered of noise, capped at MAX_PARENT_FILES.
- */
-export function getParentOutputFiles(story: UserStory, allStories: UserStory[]): string[] {
-  if (!story.dependencies || story.dependencies.length === 0) return [];
-
-  const parentFiles: string[] = [];
-  for (const depId of story.dependencies) {
-    const parent = allStories.find((s) => s.id === depId);
-    if (parent?.outputFiles) {
-      parentFiles.push(...parent.outputFiles);
-    }
-  }
-
-  const unique = [...new Set(parentFiles)];
-  return unique.filter((f) => !NOISE_PATTERNS.some((p) => p.test(f))).slice(0, MAX_PARENT_FILES);
-}