@nathapp/nax 0.18.1

package/src/context/injector.ts

@@ -0,0 +1,279 @@
+/**
+ * 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, readFileSync } 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 */
+function detectGo(workdir: string): { name?: string; lang: string; dependencies: string[] } | null {
+  const goMod = join(workdir, "go.mod");
+  if (!existsSync(goMod)) return null;
+
+  try {
+    const content = readFileSync(goMod, "utf8");
+    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 */
+function detectRust(workdir: string): { name?: string; lang: string; dependencies: string[] } | null {
+  const cargoPath = join(workdir, "Cargo.toml");
+  if (!existsSync(cargoPath)) return null;
+
+  try {
+    const content = readFileSync(cargoPath, "utf8");
+    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 */
+function detectPython(workdir: string): { 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 = readFileSync(pyproject, "utf8");
+      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 = readFileSync(requirements, "utf8")
+      .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 */
+function detectRuby(workdir: string): { name?: string; lang: string; dependencies: string[] } | null {
+  const gemfile = join(workdir, "Gemfile");
+  if (!existsSync(gemfile)) return null;
+
+  try {
+    const content = readFileSync(gemfile, "utf8");
+    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 */
+function detectJvm(workdir: string): { 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 = readFileSync(pom, "utf8");
+      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 = readFileSync(gradleFile, "utf8");
+    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 =
+    detectGo(workdir) ??
+    detectRust(workdir) ??
+    detectPython(workdir) ??
+    (await detectPhp(workdir)) ??
+    detectRuby(workdir) ??
+    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/test-scanner.ts

@@ -0,0 +1,370 @@
+/**
+ * Test File Scanner (v0.7)
+ *
+ * Scans test directories and extracts describe/test block names
+ * to generate a coverage summary for prompt injection.
+ * Prevents test duplication across isolated story sessions.
+ */
+
+import path from "node:path";
+import { Glob } from "bun";
+import { getLogger } from "../logger";
+import { estimateTokens } from "./builder";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/** Detail level for test summary */
+export type TestSummaryDetail = "names-only" | "names-and-counts" | "describe-blocks";
+
+/** Options for scanning test files */
+export interface TestScanOptions {
+  /** Working directory (base for testDir) */
+  workdir: string;
+  /** Test directory relative to workdir (default: auto-detect) */
+  testDir?: string;
+  /** Glob pattern for test files (default: "**\/*.test.{ts,js,tsx,jsx}") */
+  testPattern?: string;
+  /** Max tokens for the summary (default: 500) */
+  maxTokens?: number;
+  /** Summary detail level (default: "names-and-counts") */
+  detail?: TestSummaryDetail;
+  /** Context files to scope test coverage to (default: undefined = scan all) */
+  contextFiles?: string[];
+  /** Enable scoping to context files (default: true) */
+  scopeToStory?: boolean;
+}
+
+/** A single describe block extracted from a test file */
+export interface DescribeBlock {
+  name: string;
+  tests: string[];
+}
+
+/** Parsed test file info */
+export interface TestFileInfo {
+  /** Relative path from workdir */
+  relativePath: string;
+  /** Total test count (it/test calls) */
+  testCount: number;
+  /** Top-level describe blocks with their test names */
+  describes: DescribeBlock[];
+}
+
+/** Scan result */
+export interface TestScanResult {
+  files: TestFileInfo[];
+  totalTests: number;
+  summary: string;
+  tokens: number;
+}
+
+// ============================================================================
+// Regex Extraction
+// ============================================================================
+
+/**
+ * Extract describe and test block names from test file source.
+ *
+ * Uses regex to find:
+ * - `describe("name", ...)` / `describe('name', ...)`
+ * - `test("name", ...)` / `it("name", ...)`
+ *
+ * Only extracts top-level describes (not nested). All test/it calls
+ * are associated with the most recent describe block.
+ */
+export function extractTestStructure(source: string): { describes: DescribeBlock[]; testCount: number } {
+  const describes: DescribeBlock[] = [];
+  let currentDescribe: DescribeBlock | null = null;
+  let testCount = 0;
+
+  // Match describe/test/it calls with string arguments (single or double quotes, backticks)
+  // Match describe/test/it calls anywhere (not just line-start) to handle single-line files
+  const linePattern = /(?:^|\s|;|\{)(describe|test|it)\s*\(\s*(['"`])(.*?)\2/gm;
+
+  let match: RegExpExecArray | null = linePattern.exec(source);
+  while (match !== null) {
+    const keyword = match[1];
+    const name = match[3];
+
+    if (keyword === "describe") {
+      currentDescribe = { name, tests: [] };
+      describes.push(currentDescribe);
+    } else {
+      // test or it
+      testCount++;
+      if (currentDescribe) {
+        currentDescribe.tests.push(name);
+      } else {
+        // Top-level test without describe
+        if (describes.length === 0 || describes[describes.length - 1].name !== "(top-level)") {
+          describes.push({ name: "(top-level)", tests: [] });
+        }
+        describes[describes.length - 1].tests.push(name);
+      }
+    }
+    match = linePattern.exec(source);
+  }
+
+  return { describes, testCount };
+}
+
+// ============================================================================
+// File Scanning
+// ============================================================================
+
+/** Common test directory names to auto-detect */
+const COMMON_TEST_DIRS = ["test", "tests", "__tests__", "src/__tests__", "spec"];
+
+/**
+ * Derive test file patterns from source file paths.
+ *
+ * Maps source files to their likely test file counterparts:
+ * - src/foo.ts → test/foo.test.ts, test/foo.spec.ts
+ * - src/bar/baz.service.ts → test/bar/baz.service.test.ts, test/baz.service.test.ts
+ *
+ * @param contextFiles - Array of source file paths (relative to workdir)
+ * @returns Array of test file path patterns (basename patterns for matching)
+ */
+export function deriveTestPatterns(contextFiles: string[]): string[] {
+  const patterns = new Set<string>();
+
+  for (const filePath of contextFiles) {
+    const basename = path.basename(filePath);
+    const basenameNoExt = basename.replace(/\.(ts|js|tsx|jsx)$/, "");
+
+    // Pattern 1: exact basename match with .test/.spec extension
+    // e.g., foo.ts → foo.test.ts, foo.spec.ts
+    patterns.add(`${basenameNoExt}.test.ts`);
+    patterns.add(`${basenameNoExt}.test.js`);
+    patterns.add(`${basenameNoExt}.test.tsx`);
+    patterns.add(`${basenameNoExt}.test.jsx`);
+    patterns.add(`${basenameNoExt}.spec.ts`);
+    patterns.add(`${basenameNoExt}.spec.js`);
+    patterns.add(`${basenameNoExt}.spec.tsx`);
+    patterns.add(`${basenameNoExt}.spec.jsx`);
+
+    // Pattern 2: if basename contains .service/.controller/etc, also match without it
+    // e.g., foo.service.ts → foo.test.ts
+    const simpleBasename = basenameNoExt.replace(
+      /\.(service|controller|resolver|module|guard|middleware|util|helper)$/,
+      "",
+    );
+    if (simpleBasename !== basenameNoExt) {
+      patterns.add(`${simpleBasename}.test.ts`);
+      patterns.add(`${simpleBasename}.test.js`);
+      patterns.add(`${simpleBasename}.spec.ts`);
+      patterns.add(`${simpleBasename}.spec.js`);
+    }
+  }
+
+  return Array.from(patterns);
+}
+
+/**
+ * Auto-detect test directory by checking common locations.
+ */
+async function detectTestDir(workdir: string): Promise<string | null> {
+  for (const dir of COMMON_TEST_DIRS) {
+    const fullPath = path.join(workdir, dir);
+    const file = Bun.file(path.join(fullPath, ".")); // Check directory exists
+    try {
+      const dirStat = await Bun.file(fullPath).exists();
+      // Bun.file().exists() returns false for directories, use different check
+      const proc = Bun.spawn(["test", "-d", fullPath], { stdout: "pipe", stderr: "pipe" });
+      const exitCode = await proc.exited;
+      if (exitCode === 0) return dir;
+    } catch {}
+  }
+  return null;
+}
+
+/**
+ * Scan test files and extract structure.
+ *
+ * @param options - Scan options
+ * @returns Array of parsed test file info
+ */
+export async function scanTestFiles(options: TestScanOptions): Promise<TestFileInfo[]> {
+  const { workdir, testPattern = "**/*.test.{ts,js,tsx,jsx}", contextFiles, scopeToStory = true } = options;
+  let testDir = options.testDir;
+
+  // Auto-detect test directory if not specified
+  if (!testDir) {
+    testDir = (await detectTestDir(workdir)) || "test";
+  }
+
+  const scanDir = path.join(workdir, testDir);
+
+  // Check directory exists
+  const dirCheck = Bun.spawn(["test", "-d", scanDir], { stdout: "pipe", stderr: "pipe" });
+  if ((await dirCheck.exited) !== 0) {
+    return [];
+  }
+
+  // Derive test patterns from context files if scoping is enabled
+  let allowedBasenames: Set<string> | null = null;
+  if (scopeToStory && contextFiles && contextFiles.length > 0) {
+    const patterns = deriveTestPatterns(contextFiles);
+    allowedBasenames = new Set(patterns);
+  }
+
+  const glob = new Glob(testPattern);
+  const files: TestFileInfo[] = [];
+
+  for await (const filePath of glob.scan({ cwd: scanDir, absolute: false })) {
+    // Filter by derived patterns if scoping is enabled
+    if (allowedBasenames !== null) {
+      const basename = path.basename(filePath);
+      if (!allowedBasenames.has(basename)) {
+        continue; // Skip test files not matching context files
+      }
+    }
+
+    const fullPath = path.join(scanDir, filePath);
+    try {
+      const source = await Bun.file(fullPath).text();
+      const { describes, testCount } = extractTestStructure(source);
+
+      if (testCount > 0 || describes.length > 0) {
+        files.push({
+          relativePath: path.join(testDir, filePath),
+          testCount,
+          describes,
+        });
+      }
+    } catch {}
+  }
+
+  // Sort by path for stable output
+  files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+
+  return files;
+}
+
+// ============================================================================
+// Summary Formatting
+// ============================================================================
+
+/**
+ * Format test files as a markdown summary at the specified detail level.
+ */
+export function formatTestSummary(files: TestFileInfo[], detail: TestSummaryDetail): string {
+  if (files.length === 0) {
+    return "";
+  }
+
+  const lines: string[] = [];
+  const totalTests = files.reduce((sum, f) => sum + f.testCount, 0);
+
+  lines.push(`## Existing Test Coverage (${totalTests} tests across ${files.length} files)`);
+  lines.push("");
+  lines.push("The following tests already exist. DO NOT duplicate this coverage.");
+  lines.push("Focus only on testing NEW behavior introduced by this story.");
+  lines.push("");
+
+  for (const file of files) {
+    switch (detail) {
+      case "names-only":
+        lines.push(`- **${file.relativePath}** (${file.testCount} tests)`);
+        break;
+
+      case "names-and-counts":
+        lines.push(`### ${file.relativePath} (${file.testCount} tests)`);
+        for (const desc of file.describes) {
+          lines.push(`- ${desc.name} (${desc.tests.length} tests)`);
+        }
+        lines.push("");
+        break;
+
+      case "describe-blocks":
+        lines.push(`### ${file.relativePath} (${file.testCount} tests)`);
+        for (const desc of file.describes) {
+          lines.push(`- **${desc.name}** (${desc.tests.length} tests)`);
+          for (const test of desc.tests) {
+            lines.push(`  - ${test}`);
+          }
+        }
+        lines.push("");
+        break;
+    }
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Truncate summary to fit within token budget.
+ *
+ * Strategy: progressively reduce detail level, then truncate files.
+ */
+export function truncateToTokenBudget(
+  files: TestFileInfo[],
+  maxTokens: number,
+  preferredDetail: TestSummaryDetail,
+): { summary: string; detail: TestSummaryDetail; truncated: boolean } {
+  // Try preferred detail level first
+  const detailLevels: TestSummaryDetail[] = ["describe-blocks", "names-and-counts", "names-only"];
+  const startIndex = detailLevels.indexOf(preferredDetail);
+
+  for (let i = startIndex; i < detailLevels.length; i++) {
+    const detail = detailLevels[i];
+    const summary = formatTestSummary(files, detail);
+    const tokens = estimateTokens(summary);
+
+    if (tokens <= maxTokens) {
+      return { summary, detail, truncated: i !== startIndex };
+    }
+  }
+
+  // Even names-only exceeds budget — truncate files
+  let truncatedFiles = [...files];
+  while (truncatedFiles.length > 1) {
+    truncatedFiles = truncatedFiles.slice(0, truncatedFiles.length - 1);
+    const summary = `${formatTestSummary(truncatedFiles, "names-only")}\n... and ${files.length - truncatedFiles.length} more test files`;
+    if (estimateTokens(summary) <= maxTokens) {
+      return { summary, detail: "names-only", truncated: true };
+    }
+  }
+
+  // Last resort: just file count
+  const fallback = `## Existing Test Coverage\n\n${files.length} test files with ${files.reduce((s, f) => s + f.testCount, 0)} total tests exist. Review test/ directory before adding new tests.`;
+  return { summary: fallback, detail: "names-only", truncated: true };
+}
+
+// ============================================================================
+// Main Entry Point
+// ============================================================================
+
+/**
+ * Scan test files and generate a token-budgeted summary.
+ *
+ * @param options - Scan and formatting options
+ * @returns Scan result with summary, or empty result if no tests found
+ */
+export async function generateTestCoverageSummary(options: TestScanOptions): Promise<TestScanResult> {
+  const { maxTokens = 500, detail = "names-and-counts", contextFiles, scopeToStory = true } = options;
+
+  // Log warning if scoping is enabled but no context files provided
+  if (scopeToStory && (!contextFiles || contextFiles.length === 0)) {
+    try {
+      const logger = getLogger();
+      logger.warn("context", "scopeToStory=true but no contextFiles provided — falling back to full scan");
+    } catch {
+      // Logger not initialized (e.g., in tests) — silently skip
+    }
+  }
+
+  const files = await scanTestFiles(options);
+
+  if (files.length === 0) {
+    return { files: [], totalTests: 0, summary: "", tokens: 0 };
+  }
+
+  const totalTests = files.reduce((sum, f) => sum + f.testCount, 0);
+  const { summary } = truncateToTokenBudget(files, maxTokens, detail);
+  const tokens = estimateTokens(summary);
+
+  return { files, totalTests, summary, tokens };
+}