@nifrajs/cli 4.0.2 → 5.1.0

package/src/stylex-migrate.ts

@@ -927,17 +927,144 @@ const lineOf = (source: string, offset: number): number => {
   return line
 }
 
-const isLikelyJsxAttribute = (source: string, offset: number): boolean => {
-  const tagStart = source.lastIndexOf("<", offset)
-  const tagEnd = source.lastIndexOf(">", offset)
-  return tagStart > tagEnd && !source.slice(tagStart, offset).includes("<!--")
+/** Words after which an expression - so a regex literal or a JSX element - may start. */
+const EXPRESSION_KEYWORDS = new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "case",
+  "do",
+  "else",
+  "yield",
+  "await",
+])
+
+const WORD_CHAR = /[\w$]/
+
+/** `<` at `offset` opens an element unless it starts a type parameter list (`<T,>`, `<T extends U>`). */
+const opensElement = (source: string, offset: number): boolean => {
+  const name = /^<([A-Za-z_$][\w$.:-]*)?(\s*)/.exec(source.slice(offset, offset + 256))
+  if (name === null) return false
+  if (name[1] === undefined) return source[offset + 1] === ">"
+  const after = source.slice(offset + name[0].length, offset + name[0].length + 8)
+  return !after.startsWith(",") && !(name[2] !== "" && /^extends\b/.test(after))
 }
 
-const classAttributes = (source: string): readonly ClassAttribute[] => {
+/**
+ * Which offsets of `source` sit inside a JSX tag, where an attribute can be. A small lexer, not a
+ * parser: it steps over strings, template literals, comments and regex literals, and follows JSX by
+ * the usual rule that `<` where an expression may start opens an element. A `className=` anywhere
+ * else - HTML in a template literal, a comment, a string, JSX text - is not an attribute.
+ */
+function jsxTagMask(source: string, jsx: boolean): Uint8Array {
+  const mask = new Uint8Array(source.length)
+  const stack: ("code" | "template" | "tag" | "children")[] = ["code"]
+  const length = source.length
+  let expression = true
+  let index = 0
+  const skipQuoted = (quote: string, multiline: boolean): void => {
+    index += 1
+    while (index < length && source[index] !== quote && (multiline || source[index] !== "\n"))
+      index += source[index] === "\\" && !multiline ? 2 : 1
+    index += 1
+  }
+  while (index < length) {
+    const frame = stack[stack.length - 1]
+    const char = source[index] ?? ""
+    const next = source[index + 1]
+    if (frame === "template") {
+      if (char === "\\") index += 2
+      else if (char === "`") {
+        stack.pop()
+        index += 1
+        expression = false
+      } else if (char === "$" && next === "{") {
+        stack.push("code")
+        index += 2
+        expression = true
+      } else index += 1
+    } else if (frame === "children") {
+      if (char === "{") {
+        stack.push("code")
+        expression = true
+      } else if (char === "<" && next === "/") {
+        const close = source.indexOf(">", index)
+        index = close === -1 ? length : close
+        stack.pop()
+        expression = false
+      } else if (char === "<") stack.push("tag")
+      index += 1
+    } else if (frame === "tag") {
+      mask[index] = 1
+      if (char === '"' || char === "'") skipQuoted(char, true)
+      else if (char === "{") {
+        stack.push("code")
+        expression = true
+        index += 1
+      } else if (char === "/" && next === ">") {
+        stack.pop()
+        expression = false
+        index += 2
+      } else {
+        if (char === ">") stack[stack.length - 1] = "children"
+        index += 1
+      }
+    } else if (char === "/" && next === "/") {
+      const end = source.indexOf("\n", index)
+      index = end === -1 ? length : end
+    } else if (char === "/" && next === "*") {
+      const end = source.indexOf("*/", index + 2)
+      index = end === -1 ? length : end + 2
+    } else if (char === '"' || char === "'") {
+      skipQuoted(char, false)
+      expression = false
+    } else if (char === "`") {
+      stack.push("template")
+      index += 1
+    } else if (char === "/" && expression) {
+      let inClass = false
+      index += 1
+      while (index < length && source[index] !== "\n") {
+        const current = source[index]
+        if (current === "\\") index += 1
+        else if (current === "[") inClass = true
+        else if (current === "]") inClass = false
+        else if (current === "/" && !inClass) break
+        index += 1
+      }
+      index += 1
+      while (index < length && WORD_CHAR.test(source[index] ?? "")) index += 1
+      expression = false
+    } else if (char === "<" && expression && jsx && opensElement(source, index)) {
+      stack.push("tag")
+      index += 1
+    } else if (WORD_CHAR.test(char)) {
+      const start = index
+      while (index < length && WORD_CHAR.test(source[index] ?? "")) index += 1
+      expression = EXPRESSION_KEYWORDS.has(source.slice(start, index))
+    } else {
+      if (char === "{") stack.push("code")
+      else if (char === "}" && stack.length > 1) stack.pop()
+      if (char.trim() !== "") expression = char !== ")" && char !== "]"
+      index += 1
+    }
+  }
+  return mask
+}
+
+const classAttributes = (source: string, file: string): readonly ClassAttribute[] => {
   const attributes: ClassAttribute[] = []
+  // A TypeScript module that is not `.tsx` cannot hold JSX, and its `<T>` would read as an element.
+  const inTag = jsxTagMask(source, !/\.[cm]?ts$/.test(file))
   for (const match of source.matchAll(CLASS_ATTRIBUTE)) {
     const start = match.index ?? 0
-    if (!isLikelyJsxAttribute(source, start)) continue
+    if (inTag[start] !== 1) continue
     const end = start + match[0].length
     const value = match[1] ?? match[2] ?? match[3] ?? match[4]
     attributes.push(
@@ -972,32 +1099,131 @@ const existingStylexImport = (source: string): string | undefined => {
   return match?.[1]
 }
 
-const insertionOffset = (source: string): number => {
-  let offset = source.startsWith("#!") ? source.indexOf("\n") + 1 || source.length : 0
-  const lines = source.slice(offset).split(/(?<=\n)/)
-  let consumed = 0
-  let inImport = false
-  for (const line of lines) {
-    const trimmed = line.trim()
-    const directive = /^(['"])(?:use client|use server)\1;?$/.test(trimmed)
-    if (inImport || trimmed.startsWith("import ") || trimmed.startsWith("import{")) {
-      inImport = !/(?:from\s+["'][^"']+["']|import\s+["'][^"']+["'])\s*;?$/.test(trimmed)
-      consumed += line.length
+const isIdentifierChar = (char: string | undefined): boolean =>
+  char !== undefined && /[\w$]/.test(char)
+
+/** Past the whitespace and comments at `index`. `inLine` stops at the end of the line. */
+function skipTrivia(source: string, index: number, inLine = false): number {
+  let at = index
+  while (at < source.length) {
+    const char = source[at]
+    if (char === " " || char === "\t" || char === "\r" || (char === "\n" && !inLine)) at++
+    else if (source.startsWith("//", at)) {
+      const end = source.indexOf("\n", at)
+      if (end === -1) return source.length
+      at = inLine ? end : end + 1
+    } else if (source.startsWith("/*", at)) {
+      const end = source.indexOf("*/", at + 2)
+      if (end === -1) return source.length
+      at = end + 2
+    } else break
+  }
+  return at
+}
+
+function skipString(source: string, index: number): number {
+  const quote = source[index]
+  let at = index + 1
+  while (at < source.length && source[at] !== quote && source[at] !== "\n")
+    at += source[at] === "\\" ? 2 : 1
+  return Math.min(at + 1, source.length)
+}
+
+/** Past an import's specifier: its `with { ... }` (or `assert`) attributes and a `;`. */
+function afterSpecifier(source: string, index: number): number {
+  let at = index
+  const next = skipTrivia(source, at, true)
+  for (const keyword of ["with", "assert"]) {
+    if (!source.startsWith(keyword, next) || isIdentifierChar(source[next + keyword.length]))
+      continue
+    const open = skipTrivia(source, next + keyword.length)
+    const close = source[open] === "{" ? source.indexOf("}", open) : -1
+    if (close !== -1) at = close + 1
+  }
+  const semicolon = skipTrivia(source, at, true)
+  return source[semicolon] === ";" ? semicolon + 1 : at
+}
+
+/** Where the import declaration whose `import` keyword is at `index` ends, or `undefined` for an
+ * `import(...)` / `import.meta` expression or a declaration this scan cannot read. */
+function importEnd(source: string, index: number): number | undefined {
+  let at = skipTrivia(source, index + "import".length)
+  if (source[at] === "(" || source[at] === ".") return undefined
+  if (source[at] === '"' || source[at] === "'")
+    return afterSpecifier(source, skipString(source, at))
+  let depth = 0
+  while (at < source.length) {
+    const char = source[at]
+    if (char === '"' || char === "'") {
+      at = skipString(source, at)
       continue
     }
-    if (directive || trimmed === "") {
-      consumed += line.length
+    if (source.startsWith("//", at) || source.startsWith("/*", at)) {
+      at = skipTrivia(source, at)
       continue
     }
-    break
+    if (char === "{") depth++
+    else if (char === "}") depth--
+    else if (depth === 0 && (char === ";" || char === "=")) return undefined
+    else if (
+      depth === 0 &&
+      source.startsWith("from", at) &&
+      !isIdentifierChar(source[at - 1]) &&
+      !isIdentifierChar(source[at + 4])
+    ) {
+      const specifier = skipTrivia(source, at + 4)
+      if (source[specifier] === '"' || source[specifier] === "'")
+        return afterSpecifier(source, skipString(source, specifier))
+    }
+    at++
+  }
+  return undefined
+}
+
+/** Past the rest of the line `index` is on when only trivia is left on it, then any blank lines. */
+function nextLine(source: string, index: number): number {
+  let at = skipTrivia(source, index, true)
+  if (at < source.length && source[at] !== "\n") return index
+  for (;;) {
+    if (source[at] !== "\n") return at
+    let next = at + 1
+    while (source[next] === " " || source[next] === "\t" || source[next] === "\r") next++
+    if (next < source.length && source[next] !== "\n") return at + 1
+    at = next
+  }
+}
+
+/**
+ * Where the generated block goes: after the directive prologue and the import declarations. Comments
+ * are read as comments, so one before `"use client"` keeps the directive first, and a trailing
+ * `// note` on the last import does not hide where it ends.
+ */
+const insertionOffset = (source: string): number => {
+  let end = source.startsWith("#!") ? source.indexOf("\n") + 1 || source.length : 0
+  let prologue = true
+  for (;;) {
+    const at = skipTrivia(source, end)
+    const char = source[at]
+    let statementEnd: number | undefined
+    if (prologue && (char === '"' || char === "'")) {
+      const literal = skipString(source, at)
+      const after = skipTrivia(source, literal, true)
+      // A string with more of an expression after it on its line is not a directive.
+      if (source[after] === ";") statementEnd = after + 1
+      else if (after === source.length || source[after] === "\n") statementEnd = literal
+    } else if (source.startsWith("import", at) && !isIdentifierChar(source[at + 6])) {
+      prologue = false
+      statementEnd = importEnd(source, at)
+    }
+    if (statementEnd === undefined) break
+    end = nextLine(source, statementEnd)
   }
-  offset += consumed
-  return offset
+  return end
 }
 
 /** Transform one source file. The returned source is unchanged when every match is unsupported. */
 export function migrateTailwindSource(source: string, file: string): SourceMigration {
-  const attributes = classAttributes(source)
+  const attributes = classAttributes(source, file)
   if (attributes.length === 0) return { source, changed: false, replacements: 0, issues: [] }
 
   const replacements: { start: number; end: number; text: string }[] = []
@@ -1069,7 +1295,8 @@ export function migrateTailwindSource(source: string, file: string): SourceMigra
   const needsImport = existingStylexImport(source) === undefined
   const generated = `${needsImport ? `import * as ${stylexName} from "${STYLEX_SPECIFIER}"\n\n` : ""}const ${stylesName} = ${stylexName}.create(${JSON.stringify(Object.fromEntries(styles), null, 2)})\n\n`
   const offset = insertionOffset(rewritten)
-  const withGenerated = `${rewritten.slice(0, offset)}${generated}${rewritten.slice(offset)}`
+  const separator = offset > 0 && rewritten[offset - 1] !== "\n" ? "\n" : ""
+  const withGenerated = `${rewritten.slice(0, offset)}${separator}${generated}${rewritten.slice(offset)}`
   return { source: withGenerated, changed: true, replacements: replacements.length, issues }
 }
 

package/src/test-tool.ts

@@ -1,4 +1,10 @@
-import { type HeadTailOutput, readHeadTail } from "./mcp-io.ts"
+import {
+  escalatingStop,
+  type HeadTailOutput,
+  OWN_PROCESS_GROUP,
+  readHeadTail,
+  signalProcessGroup,
+} from "./mcp-io.ts"
 import { mcpProjectPathError, resolveMcpProjectPath } from "./mcp-path.ts"
 
 export interface TestToolArgs {
@@ -146,17 +152,19 @@ export async function collectTestResult(
     env: process.env,
     stdout: "pipe",
     stderr: "pipe",
+    detached: OWN_PROCESS_GROUP,
   })
   let timedOut = false
   let cancelled = false
+  const { stop, dispose } = escalatingStop((name) => signalProcessGroup(proc, name))
   const abort = (): void => {
     cancelled = true
-    proc.kill()
+    stop()
   }
   opts.signal?.addEventListener("abort", abort, { once: true })
   const timer = setTimeout(() => {
     timedOut = true
-    proc.kill()
+    stop()
   }, timeoutMs)
   const empty: HeadTailOutput = { head: "", tail: "", droppedBytes: 0 }
   let stdoutRaw = empty
@@ -175,6 +183,7 @@ export async function collectTestResult(
     exitCode = result[2]
   } finally {
     clearTimeout(timer)
+    dispose()
     opts.signal?.removeEventListener("abort", abort)
   }
   const stdout = clean(stdoutRaw)

package/src/typecheck-coverage.ts

@@ -0,0 +1,134 @@
+/**
+ * Which zoned files the typecheck never read. `tsc --noEmit` passes for code outside its program, so
+ * a stale tsconfig `include` (a folder moved under `backend/`, say) turns the contract gate into a
+ * pass that checked nothing there. The check runs tsc with `--listFiles` and compares the program
+ * against the app's zone folders.
+ */
+import { existsSync, readFileSync, realpathSync } from "node:fs"
+import { dirname, isAbsolute, join, relative, resolve } from "node:path"
+import { stripComments } from "./check-scan.ts"
+
+const ZONE_FOLDER = new Set(["routes", "frontend", "backend", "shared"])
+const TS_SOURCE = /\.(?:[cm]?ts|tsx)$/
+const NOT_PROGRAM_CODE = /\.d\.[cm]?ts$|\.(?:test|spec)\.[cm]?tsx?$/
+const TSC_DIAGNOSTIC = /\(\d+,\d+\):\s*(?:error|warning)\s+TS\d+:/
+
+/** Split `tsc --listFiles` output into the program's files and the compiler's own output. */
+export function splitListedFiles(output: string): {
+  readonly programFiles: readonly string[]
+  readonly output: string
+} {
+  const programFiles: string[] = []
+  const rest: string[] = []
+  for (const line of output.split(/\r?\n/)) {
+    if (line !== "" && line === line.trim() && isAbsolute(line) && !TSC_DIAGNOSTIC.test(line))
+      programFiles.push(line)
+    else rest.push(line)
+  }
+  return { programFiles, output: rest.join("\n").trim() }
+}
+
+const real = (path: string): string => {
+  try {
+    return realpathSync.native(path)
+  } catch {
+    return path
+  }
+}
+
+// tsc prints forward slashes, and on Windows the drive letter's case is not stable.
+const canonical = (path: string): string => {
+  const posix = path.replaceAll("\\", "/")
+  return process.platform === "win32" ? posix.toLowerCase() : posix
+}
+
+/** The zone folder a project file sits in (`backend`, `apps/web/routes`), or `undefined`. */
+export function zoneFolderOf(file: string): string | undefined {
+  const parts = file.split("/")
+  const at = parts.findIndex((part, i) => i < parts.length - 1 && ZONE_FOLDER.has(part))
+  return at === -1 ? undefined : parts.slice(0, at + 1).join("/")
+}
+
+/** True when a tsconfig between the app root and `cwd` makes the app its own program. */
+function hasOwnProgram(cwd: string, app: string): boolean {
+  let dir = app
+  while (dir !== "" && dir !== ".") {
+    if (existsSync(join(cwd, dir, "tsconfig.json"))) return true
+    const parent = dirname(dir)
+    if (parent === dir) return false
+    dir = parent
+  }
+  return false
+}
+
+/**
+ * The `exclude` patterns of `<cwd>/tsconfig.json`, inherited through relative `extends` as tsc does,
+ * rewritten relative to `cwd`. A file a tsconfig excludes is out of the program on purpose.
+ */
+export function tsconfigExcludes(cwd: string): string[] {
+  let path = join(cwd, "tsconfig.json")
+  for (let depth = 0; depth < 8 && existsSync(path); depth++) {
+    let config: unknown
+    try {
+      config = JSON.parse(stripComments(readFileSync(path, "utf8")).replace(/,(\s*[}\]])/g, "$1"))
+    } catch {
+      return []
+    }
+    if (typeof config !== "object" || config === null) return []
+    const exclude: unknown = Reflect.get(config, "exclude")
+    if (Array.isArray(exclude)) {
+      const from = dirname(path)
+      return exclude
+        .filter((pattern): pattern is string => typeof pattern === "string")
+        .map((pattern) => relative(cwd, resolve(from, pattern)).replaceAll("\\", "/"))
+    }
+    const base: unknown = Reflect.get(config, "extends")
+    if (typeof base !== "string" || !base.startsWith(".")) return []
+    path = resolve(dirname(path), base.endsWith(".json") ? base : `${base}.json`)
+  }
+  return []
+}
+
+// tsc reads a pattern that names a folder as everything below it.
+const excludedBy = (patterns: readonly string[], file: string): boolean =>
+  patterns.some(
+    (pattern) => new Bun.Glob(pattern).match(file) || new Bun.Glob(`${pattern}/**`).match(file),
+  )
+
+/**
+ * The TypeScript files under a zone folder that `programFiles` does not contain, project-relative and
+ * in input order. Declaration files and tests are left out: a project may typecheck tests with a
+ * separate config. So is an app nested under its own tsconfig, which this program does not own, and a
+ * file the tsconfig's `exclude` names.
+ */
+export function filesOutsideProgram(
+  cwd: string,
+  files: readonly string[],
+  programFiles: readonly string[],
+): string[] {
+  const program = new Set<string>()
+  for (const file of programFiles) {
+    program.add(canonical(file))
+    if (!file.includes("/node_modules/")) program.add(canonical(real(file)))
+  }
+  const ownProgram = new Map<string, boolean>()
+  const excluded = tsconfigExcludes(cwd)
+  const outside: string[] = []
+  for (const file of files) {
+    if (!TS_SOURCE.test(file) || NOT_PROGRAM_CODE.test(file)) continue
+    if (excludedBy(excluded, file)) continue
+    const folder = zoneFolderOf(file)
+    if (folder === undefined) continue
+    const app = dirname(folder)
+    let own = ownProgram.get(app)
+    if (own === undefined) {
+      own = hasOwnProgram(cwd, app)
+      ownProgram.set(app, own)
+    }
+    if (own) continue
+    const abs = join(cwd, file)
+    if (program.has(canonical(abs)) || program.has(canonical(real(abs)))) continue
+    outside.push(file)
+  }
+  return outside
+}