jackherd 1.12.7 → 1.14.0

package/src/check/plan-structure-check.ts

@@ -1,5 +1,8 @@
 import { existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
+import { dirname, join, posix } from 'node:path'
+import { boardPlansOf, isInsideRepository } from '../../kit/hooks/hooks/shared/board-lanes'
+import { planCopiesIn } from '../../kit/hooks/hooks/shared/boards'
+import { codesOfPlans } from '../../kit/hooks/hooks/shared/plan-codes'
 import {
   boardRowsWithoutPhase,
   boardRowsWithProse,
@@ -25,6 +28,7 @@ import {
   type ShortNameFinding,
   shortNameFindings,
 } from '../plan-format'
+import { boardRowsWithBareCodes, type RowWithBareCode } from '../plan-format/bare-codes'
 import { changedPlansOf } from './deferral-arrows'
 import { CHECK_STATUS, type CheckResult } from './result'
 
@@ -42,6 +46,8 @@ export type PlanCheckInput = {
   language: PlanLanguage
   previousOf: ContentAt
   baseOf: ContentAt
+  /** Where a board's plans are read, `root` when absent: the checkout, the main checkout and the lane worktrees. */
+  planRoots?: readonly string[]
 }
 
 type Changed = {
@@ -116,6 +122,16 @@ const proseReport: Report<RowWithProse> = {
   clean: 'every changed lane row names the phase only',
 }
 
+const bareCodeReport: Report<RowWithBareCode> = {
+  name: 'Board rows with a bare plan code',
+  noun: 'board',
+  rule: 'changed waiting rows say what a plan code is',
+  unmet: CHECK_STATUS.warn,
+  text: ({ path, line, code }) =>
+    `${path}:${line} plan code ${code} without its words: say what it is, the code at most in brackets after it`,
+  clean: 'no changed waiting row names a plan code bare',
+}
+
 const mergedReport: Report<MergedPhaseWithOpenBoxes> = {
   name: 'Merged phases with open boxes',
   noun: 'plan',
@@ -175,6 +191,20 @@ const rowsOf = ({ path, current, previousLines }: Changed, language: PlanLanguag
 const proseOf = ({ path, current, previousLines }: Changed, language: PlanLanguage): Found<RowWithProse>[] =>
   boardRowsWithProse(current, language, previousLines).map(withPath(path))
 
+/** Every readable copy of the plans the board links, in each plan root; a path that leaves the repository is skipped. */
+const planTextsOf = (roots: readonly string[], { path, current }: Changed, language: PlanLanguage): string[] =>
+  boardPlansOf(current, posix.normalize(dirname(path)), language)
+    .filter(isInsideRepository)
+    .flatMap((plan) => planCopiesIn(roots, plan))
+
+const bareCodesOfBoard = (roots: readonly string[], file: Changed, language: PlanLanguage): Found<RowWithBareCode>[] =>
+  boardRowsWithBareCodes(
+    file.current,
+    language,
+    file.previousLines,
+    codesOfPlans(planTextsOf(roots, file, language), language),
+  ).map(withPath(file.path))
+
 const mergedOf = ({ path, current, base }: Changed, language: PlanLanguage): Found<MergedPhaseWithOpenBoxes>[] =>
   base ? mergedPhasesWithOpenBoxes(current, base, language).map(withPath(path)) : []
 
@@ -202,6 +232,7 @@ const changedContents = ({ root, previousOf, baseOf, language }: PlanCheckInput,
  * - a phase the change added (against `HEAD`) with tasks and without a review gate fails;
  * - a lane row the change added or edited that names no phase warns, and so does one whose phases cell is longer
  *   than `PHASE_CELL_LIMIT` or records a side order of the user;
+ * - a waiting row the change added or edited whose item cell names a plan code of the board's plans bare warns;
  * - a phase whose tasks are all ticked on the base branch and that still has open boxes without `→ P<n>` warns;
  * - a phase of a plan with a dependency table that has no row in it warns;
  * - an open task the change added or edited without a short name, or with one over `SHORT_NAME_LIMIT`, warns, and so
@@ -222,6 +253,7 @@ export const planStructureChecks = (input: PlanCheckInput): CheckResult[] => {
   const gates = changed.flatMap((file) => gatesOf(file, language))
   const rows = boards.flatMap((file) => rowsOf(file, language))
   const prose = boards.flatMap((file) => proseOf(file, language))
+  const bareCodes = boards.flatMap((file) => bareCodesOfBoard(input.planRoots ?? [input.root], file, language))
   const merged = plans.flatMap((file) => mergedOf(file, language))
   const unlisted = unlistedPerPlan.flat()
   const shortNames = plans.flatMap((file) => shortNamesOf(file, language))
@@ -233,6 +265,7 @@ export const planStructureChecks = (input: PlanCheckInput): CheckResult[] => {
       ? [
           findingsResult(rowReport, rows, boards.length, durationMs),
           findingsResult(proseReport, prose, boards.length, durationMs),
+          findingsResult(bareCodeReport, bareCodes, boards.length, durationMs),
         ]
       : []),
     ...(plans.length > 0 ? [findingsResult(mergedReport, merged, plans.length, durationMs)] : []),

package/src/check/plan.ts

@@ -1,31 +1,69 @@
 import type { JackherdConfig } from '../config'
+import { STACKS, type Stack, type StackProfile } from '../config/detect'
 import { agentTextReviewers } from './agent-text-reviewers'
 import { type ChangedFile, generatorOwnedFiles, stagedBuildArtifacts } from './changes'
 import { tokenize } from './command-line'
-import { looseDirectories, packageRootsFor } from './roots'
+import { hasNamedTest, isSourceFile, isTestFile, testStemsOf } from './file-kinds'
+import { matchesAnyGlob } from './glob'
+import { CHECK_KIND, type CheckKind } from './result'
+import { isUnder, looseDirectories, nearestRootOf, packageRootOf, packageRootsFor } from './roots'
 import { projectChecksFor, publicContentReviewers, reviewersFor } from './routing'
-import type { CheckConfig } from './schema'
+import type { CheckConfig, ProjectCheck } from './schema'
 
-export const CHECK_KIND = { lint: 'lint', project: 'project', types: 'types', tests: 'tests' } as const
-
-export type CheckKind = (typeof CHECK_KIND)[keyof typeof CHECK_KIND]
+export { CHECK_KIND, type CheckKind } from './result'
 
 export type PlannedCheck = {
   name: string
   /** What the report shows; `argv` is what runs. */
   command: string
   argv: string[]
-  /** Relative to the workspace root. */
+  /** Relative to the repository root `.`. */
   cwd: string
   kind: CheckKind
 }
 
-export type PackageCommands = Pick<JackherdConfig['commands'], 'test' | 'typecheck'>
+export type PackageCommands = Pick<JackherdConfig['commands'], 'test' | 'typecheck' | 'lint'>
 
+/** What the plan asks of the disk, by the markers of the stack (`checkStackOf`). */
 export type Filesystem = {
-  hasPackageJson: (dir: string) => boolean
-  hasTsconfig: (dir: string) => boolean
+  /** Whether the directory holds the stack's root marker (`package.json`, `composer.json`). */
+  isProjectRoot: (dir: string) => boolean
+  /** Whether the directory only gathers workspaces, so a test from there would run the whole monorepo. */
+  isWorkspaceRoot: (dir: string) => boolean
+  /** Whether the directory holds a type marker of the stack (`tsconfig.json`, `phpstan.neon`). */
+  hasTypeConfig: (dir: string) => boolean
   hasTests: (dir: string) => boolean
+  /** Every file of the repository that git tracks or does not ignore; read only for the name rule. */
+  repositoryFiles: () => readonly string[]
+}
+
+/** The stack as the check reads it; with none or several detected, every stack's markers and patterns together. */
+export type CheckStack = {
+  rootMarkers: string[]
+  typeMarkers: string[]
+  testFile: RegExp
+  sourceFile: RegExp
+  /** Globs the lint covers; none means every changed file. */
+  lintGlobs: string[]
+}
+
+/** What the check reads only where no stack is detected at all (not where several are). */
+export type NoStackFallback = {
+  /** `check.roots` and the repository root `.`: a file no root marker holds belongs to the nearest one above it. */
+  roots: readonly string[]
+  /** `commands.lint`, run once from `.` where no `check.lintFilesCommand` is set. */
+  lintCommand?: string
+}
+
+/** What the plan reads from the settings: the test and type commands, the `check` block and the stack's patterns. */
+export type PlanInputs = {
+  commands: PackageCommands
+  check: CheckConfig
+  stack: Pick<CheckStack, 'lintGlobs' | 'sourceFile'>
+  /** Repository paths of the kit's copies (`.jackherd/lock.json`); their tests run where the kit keeps the source. */
+  kitCopies: readonly string[]
+  /** Null where a stack is detected, or several. */
+  noStackFallback: NoStackFallback | null
 }
 
 export type CheckPlan = {
@@ -36,26 +74,113 @@ export type CheckPlan = {
   artifacts: string[]
   /** Fast checks first, then the ones that scale with the package; the runner starts each group together. */
   checks: PlannedCheck[]
+  /** The changed source files of the stack no planned test reaches, kit copies aside; a check without a test is no green. */
+  untestedSources: string[]
+  /**
+   * Without a detected stack, the changed source files under a root found by `NoStackFallback.roots` that no test file
+   * of their name covers: a run from such a root reaches every file, so the name decides, and only as a warning.
+   */
+  sourcesWithoutNamedTest: string[]
 }
 
+/** The roots of a change: by root marker, and without a detected stack by `NoStackFallback.roots` for the rest. */
+type ChangeRoots = { roots: string[]; fallbackRoots: string[]; fallbackPaths: string[] }
+
+/** What reaches a changed file: a test run from a directory above it, or a fired project check of kind tests whose globs (or no globs) match it. */
+type TestReach = { dirs: readonly string[]; checks: readonly ProjectCheck[] }
+
+/** Which changed source files no test covers: the paths under marker roots by reach, the fallback paths by name. */
+type Coverage = Pick<CheckPlan, 'untestedSources' | 'sourcesWithoutNamedTest'>
+
 export const isSlow = (check: PlannedCheck): boolean =>
   check.kind === CHECK_KIND.types || check.kind === CHECK_KIND.tests
 
-const lintCheck = (config: CheckConfig, paths: readonly string[]): PlannedCheck => ({
-  name: 'Lint & unused imports',
-  command: `${config.lintFilesCommand} (${paths.length} files)`,
-  argv: [...tokenize(config.lintFilesCommand), ...paths],
-  cwd: '.',
-  kind: CHECK_KIND.lint,
-})
+const unique = (values: readonly string[]): string[] => [...new Set(values)]
+
+const anyOf = (patterns: readonly RegExp[]): RegExp =>
+  new RegExp(unique(patterns.map((pattern) => `(?:${pattern.source})`)).join('|'))
+
+const lintGlobsOf = (profiles: readonly StackProfile[]): string[] =>
+  profiles.some((profile) => profile.lintGlobs.length === 0)
+    ? []
+    : unique(profiles.flatMap((profile) => profile.lintGlobs))
+
+export const checkStackOf = (stack: Stack | null): CheckStack => {
+  const profiles = stack === null ? Object.values(STACKS) : [STACKS[stack]]
+  return {
+    rootMarkers: unique(profiles.map((profile) => profile.rootMarker)),
+    typeMarkers: unique(profiles.flatMap((profile) => profile.typeMarkers)),
+    testFile: anyOf(profiles.map((profile) => profile.testFilePattern)),
+    sourceFile: anyOf(profiles.map((profile) => profile.sourceFilePattern)),
+    lintGlobs: lintGlobsOf(profiles),
+  }
+}
 
-const projectChecks = (config: CheckConfig, paths: readonly string[]): PlannedCheck[] =>
-  projectChecksFor(paths, config.checks).map(({ name, command }) => ({
+const lintedPaths = (paths: readonly string[], lintGlobs: readonly string[]): string[] =>
+  lintGlobs.length === 0 ? [...paths] : paths.filter((path) => matchesAnyGlob(path, lintGlobs))
+
+/** A predicate from the configured globs, or the given one where none are configured. */
+const globsOr =
+  (globs: readonly string[] | undefined, fallback: (path: string) => boolean) =>
+  (path: string): boolean =>
+    globs === undefined ? fallback(path) : matchesAnyGlob(path, globs)
+
+/** Each path no root marker holds, with the nearest fallback root above it; paths without one are left out. */
+const fallbackRootsOf = (
+  paths: readonly string[],
+  fallback: readonly string[],
+  isProjectRoot: Filesystem['isProjectRoot'],
+): { path: string; root: string }[] =>
+  paths.flatMap((path) => {
+    const root = packageRootOf(path, isProjectRoot) === null ? nearestRootOf(path, fallback) : null
+    return root === null ? [] : [{ path, root }]
+  })
+
+const changeRootsOf = (
+  paths: readonly string[],
+  fallback: readonly string[],
+  { isProjectRoot, isWorkspaceRoot }: Pick<Filesystem, 'isProjectRoot' | 'isWorkspaceRoot'>,
+): ChangeRoots => {
+  const isTestable = (root: string) => !isWorkspaceRoot(root)
+  const fallbackPairs = fallbackRootsOf(paths, fallback, isProjectRoot)
+  const fallbackPaths = fallbackPairs.map(({ path }) => path)
+  const fallbackRoots = unique(fallbackPairs.map(({ root }) => root)).filter(isTestable)
+  const markerRoots = packageRootsFor(paths, isProjectRoot).filter(isTestable)
+  return { roots: unique([...markerRoots, ...fallbackRoots]), fallbackRoots, fallbackPaths }
+}
+
+/** No lint without a `lintFilesCommand`, none is guessed; none either when no changed file is the stack's to lint. */
+const lintChecks = (command: string | undefined, paths: readonly string[]): PlannedCheck[] =>
+  command === undefined || paths.length === 0
+    ? []
+    : [
+        {
+          name: 'Lint & unused imports',
+          command: `${command} (${paths.length} files)`,
+          argv: [...tokenize(command), ...paths],
+          cwd: '.',
+          kind: CHECK_KIND.lint,
+        },
+      ]
+
+/** Without a detected stack and a `lintFilesCommand`, the project's lint once from the repository root. */
+const projectLint = (command: string | undefined): PlannedCheck[] =>
+  command === undefined ? [] : [{ name: 'Lint', command, argv: tokenize(command), cwd: '.', kind: CHECK_KIND.lint }]
+
+const lintOf = (
+  lintFilesCommand: string | undefined,
+  noStackFallback: NoStackFallback | null,
+  paths: readonly string[],
+): PlannedCheck[] =>
+  lintFilesCommand === undefined ? projectLint(noStackFallback?.lintCommand) : lintChecks(lintFilesCommand, paths)
+
+const projectChecks = (fired: readonly ProjectCheck[]): PlannedCheck[] =>
+  fired.map(({ name, command, kind }) => ({
     name,
     command,
     argv: tokenize(command),
     cwd: '.',
-    kind: CHECK_KIND.project,
+    kind: kind ?? CHECK_KIND.project,
   }))
 
 const inDirectory = (kind: CheckKind, label: string, command: string, dir: string): PlannedCheck => ({
@@ -66,48 +191,108 @@ const inDirectory = (kind: CheckKind, label: string, command: string, dir: strin
   kind,
 })
 
+/** No type check without `commands.typecheck`, no test without `commands.test`: none is guessed. */
 const typeChecks = (
   roots: readonly string[],
-  command: string,
-  hasTsconfig: Filesystem['hasTsconfig'],
-): PlannedCheck[] => roots.filter(hasTsconfig).map((root) => inDirectory(CHECK_KIND.types, 'Types', command, root))
+  command: string | undefined,
+  isTypeRoot: (root: string) => boolean,
+): PlannedCheck[] =>
+  command === undefined
+    ? []
+    : roots.filter(isTypeRoot).map((root) => inDirectory(CHECK_KIND.types, 'Types', command, root))
+
+const testChecks = (dirs: readonly string[], command: string | undefined): PlannedCheck[] =>
+  command === undefined ? [] : dirs.map((dir) => inDirectory(CHECK_KIND.tests, 'Tests', command, dir))
+
+const isReached = (path: string, { dirs, checks }: TestReach): boolean =>
+  dirs.some((dir) => isUnder(path, dir)) ||
+  checks.some(({ globs }) => globs === undefined || matchesAnyGlob(path, globs))
+
+/** Each changed source file on its own: one test elsewhere in the change does not cover it. */
+const untestedSourcesOf = (
+  paths: readonly string[],
+  reach: TestReach,
+  { isSource, kitCopies }: { isSource: (path: string) => boolean; kitCopies: readonly string[] },
+): string[] => paths.filter((path) => isSource(path) && !kitCopies.includes(path) && !isReached(path, reach))
+
+/** The source files among `paths` with no test file of their name in the repository, read only when there are any. */
+const sourcesWithoutNamedTestOf = (
+  paths: readonly string[],
+  testChecks: readonly ProjectCheck[],
+  { check, kitCopies }: Pick<PlanInputs, 'check' | 'kitCopies'>,
+  repositoryFiles: Filesystem['repositoryFiles'],
+): string[] => {
+  const isTest = globsOr(check.testFiles, isTestFile)
+  const isNamedSource = globsOr(check.sourceFiles, isSourceFile)
+  const isSource = (path: string) => !isTest(path) && isNamedSource(path)
+  const candidates = untestedSourcesOf(paths, { dirs: [], checks: testChecks }, { isSource, kitCopies })
+  if (candidates.length === 0) return []
+  const testStems = testStemsOf(repositoryFiles(), isTest)
+  return candidates.filter((path) => !hasNamedTest(path, testStems))
+}
+
+const coverageOf = (
+  { paths, fallbackPaths }: { paths: readonly string[]; fallbackPaths: readonly string[] },
+  reach: TestReach,
+  { check, stack, kitCopies }: Pick<PlanInputs, 'check' | 'stack' | 'kitCopies'>,
+  repositoryFiles: Filesystem['repositoryFiles'],
+): Coverage => {
+  const markerPaths = paths.filter((path) => !fallbackPaths.includes(path))
+  const isSource = globsOr(check.sourceFiles, (path) => stack.sourceFile.test(path))
+  return {
+    untestedSources: untestedSourcesOf(markerPaths, reach, { isSource, kitCopies }),
+    sourcesWithoutNamedTest: sourcesWithoutNamedTestOf(
+      fallbackPaths,
+      reach.checks,
+      { check, kitCopies },
+      repositoryFiles,
+    ),
+  }
+}
 
-const testChecks = (dirs: readonly string[], command: string): PlannedCheck[] =>
-  dirs.map((dir) => inDirectory(CHECK_KIND.tests, 'Tests', command, dir))
+/** The reviewers a set of changed paths calls for, each named once: routed, public content and agent texts. */
+export const reviewersOf = (paths: readonly string[], config: CheckConfig): string[] => [
+  ...new Set([
+    ...reviewersFor(paths, config.reviewerRoutes),
+    ...publicContentReviewers(paths, config.publicContent),
+    ...agentTextReviewers(paths),
+  ]),
+]
 
 /**
  * Decides, without touching the disk or running anything, what a set of changed files calls for:
- * which package roots to type-check and test, which project checks fire, which reviewers to start.
+ * which package roots to type-check and test, which project checks fire, which reviewers to start,
+ * and which changed source files no test covers. A root that gathers workspaces is never tested. Without a
+ * detected stack, a file no root marker holds is tested from its `NoStackFallback.roots` entry and judged by its name.
  */
 export const planChecks = (
   files: readonly ChangedFile[],
-  commands: PackageCommands,
-  config: CheckConfig,
+  { commands, check: config, stack, kitCopies, noStackFallback }: PlanInputs,
   filesystem: Filesystem,
 ): CheckPlan => {
   const paths = files.map((file) => file.path)
-  const roots = packageRootsFor(paths, filesystem.hasPackageJson).filter((root) => root !== '.')
-  const looseDirs = config.looseTests ? looseDirectories(paths, roots, filesystem.hasTests) : []
+  const { roots, fallbackRoots, fallbackPaths } = changeRootsOf(paths, noStackFallback?.roots ?? [], filesystem)
+  const isTypeRoot = (root: string) => fallbackRoots.includes(root) || filesystem.hasTypeConfig(root)
+  const loose = config.looseTests ? looseDirectories(paths, roots, filesystem.hasTests) : []
+  const fired = projectChecksFor(paths, config.checks)
+  const testDirs = commands.test === undefined ? [] : [...roots, ...loose]
+  const checks =
+    paths.length === 0
+      ? []
+      : [
+          ...lintOf(config.lintFilesCommand, noStackFallback, lintedPaths(paths, stack.lintGlobs)),
+          ...projectChecks(fired),
+          ...typeChecks(roots, commands.typecheck, isTypeRoot),
+          ...testChecks(testDirs, commands.test),
+        ]
+  const reach: TestReach = { dirs: testDirs, checks: fired.filter((check) => check.kind === CHECK_KIND.tests) }
   return {
     paths,
     roots,
-    reviewers: [
-      ...new Set([
-        ...reviewersFor(paths, config.reviewerRoutes),
-        ...publicContentReviewers(paths, config.publicContent),
-        ...agentTextReviewers(paths),
-      ]),
-    ],
+    reviewers: reviewersOf(paths, config),
     generated: generatorOwnedFiles(paths, config.generatorOwned),
     artifacts: stagedBuildArtifacts(files, config.buildArtifacts),
-    checks:
-      paths.length === 0
-        ? []
-        : [
-            lintCheck(config, paths),
-            ...projectChecks(config, paths),
-            ...typeChecks(roots, commands.typecheck, filesystem.hasTsconfig),
-            ...testChecks([...roots, ...looseDirs], commands.test),
-          ],
+    checks,
+    ...coverageOf({ paths, fallbackPaths }, reach, { check: config, stack, kitCopies }, filesystem.repositoryFiles),
   }
 }

package/src/check/report.ts

@@ -1,6 +1,9 @@
+import { STACKS, type StackDetection, stackOfCommand } from '../config/detect'
+import { PROJECT_CONFIG_PATH } from '../config/location'
+import { CLI_NAME } from '../version/release'
 import { type ChangedFile, STATUS_COMMAND } from './changes'
-import type { CheckPlan } from './plan'
-import { CHECK_STATUS, type CheckResult, SKIP_SLOW_FLAG } from './result'
+import type { CheckPlan, PackageCommands } from './plan'
+import { CHECK_STATUS, type CheckResult, type CheckStatus, RUN_MODE, type RunMode, SKIP_SLOW_FLAG } from './result'
 
 const STATUS_ICON = { pass: '✅', fail: '❌', warn: '⚠️ ', skipped: '⏭️ ' } as const
 
@@ -20,10 +23,115 @@ export const skippedSlowResult = (): CheckResult => ({
   durationMs: 0,
 })
 
-export const formatPlanHeader = (files: readonly ChangedFile[], plan: CheckPlan): string[] => [
+const plural = (count: number, noun: string): string => `${count} ${noun}${count === 1 ? '' : 's'}`
+
+/** A full run fails on a changed source file no test covers; a quick one runs no test by design, so it warns. */
+export const UNTESTED_STATUS: Record<RunMode, CheckStatus> = {
+  [RUN_MODE.full]: CHECK_STATUS.fail,
+  [RUN_MODE.quick]: CHECK_STATUS.warn,
+}
+
+/** A changed source file of the stack with no test planned, with the status `UNTESTED_STATUS` gives the run mode. */
+export const untestedResult = (sources: readonly string[], mode: RunMode): CheckResult | null =>
+  sources.length === 0
+    ? null
+    : {
+        name: 'Tests',
+        command: 'commands.test',
+        status: UNTESTED_STATUS[mode],
+        detail: [
+          `no test ran for ${plural(sources.length, 'changed source file')}; set \`commands.test\` or a \`check.checks\` entry with \`kind: "tests"\``,
+          ...sources,
+        ].join('\n'),
+        durationMs: 0,
+      }
+
+/** Without a detected stack, the changed source files no test file of their name covers: a warning in every run mode. */
+export const namedTestResult = (sources: readonly string[]): CheckResult | null =>
+  sources.length === 0
+    ? null
+    : {
+        name: 'Tests by name',
+        command: 'check.testFiles',
+        status: CHECK_STATUS.warn,
+        detail: [
+          `no test file named like ${plural(sources.length, 'changed source file')}; add one, or name the test files in \`check.testFiles\``,
+          ...sources,
+        ].join('\n'),
+        durationMs: 0,
+      }
+
+/** Without a detected stack nothing derives `commands.test`, and a check without it tests nothing, so it fails. */
+export const missingTestCommandResult = (command: string | undefined, detection: StackDetection): CheckResult | null =>
+  command !== undefined || detection.kind !== 'none'
+    ? null
+    : {
+        name: 'Test command',
+        command: 'commands.test',
+        status: CHECK_STATUS.fail,
+        detail: `no stack detected and no \`commands.test\` set; set it in ${PROJECT_CONFIG_PATH} (\`${CLI_NAME} config test\` names the line, \`/jh-start\` proposes it from the CI)`,
+        durationMs: 0,
+      }
+
+/** Without a detected stack a missing type or lint command is a note, not a result: not every language has the step. */
+export const missingCommandNotes = (
+  commands: PackageCommands,
+  lintFilesCommand: string | undefined,
+  detection: StackDetection,
+): string[] => {
+  if (detection.kind !== 'none') return []
+  return [
+    ...(commands.typecheck === undefined ? [`${CLI_NAME}: no \`commands.typecheck\` set; no type check runs.`] : []),
+    ...(commands.lint === undefined && lintFilesCommand === undefined
+      ? [`${CLI_NAME}: neither \`check.lintFilesCommand\` nor \`commands.lint\` set; no lint runs.`]
+      : []),
+  ]
+}
+
+/** The lock files of known stacks the repository holds; none means it has not installed yet. */
+const presentLockFiles = (detection: StackDetection): readonly string[] => {
+  if (detection.kind === 'found') return [detection.lockFile]
+  return detection.kind === 'ambiguous' ? detection.lockFiles : []
+}
+
+/**
+ * A failure when `commands.test` belongs to a known stack whose lock files the repository lacks (`bun test` beside
+ * only `composer.lock`): such a run finds no test and would read as green. Null for a command of no known stack,
+ * for no command, and in a repository without any lock file.
+ */
+export const testCommandResult = (command: string | undefined, detection: StackDetection): CheckResult | null => {
+  const stack = command === undefined ? undefined : stackOfCommand(command)
+  const present = presentLockFiles(detection)
+  if (stack === undefined || present.length === 0) return null
+  const { lockFiles } = STACKS[stack]
+  if (lockFiles.some((file) => present.includes(file))) return null
+  return {
+    name: 'Test command',
+    command: 'commands.test',
+    status: CHECK_STATUS.fail,
+    detail: `\`${command}\` needs ${lockFiles.join(' or ')}, which is missing; set \`commands.test\` for this repository's stack (\`${CLI_NAME} config test\` names the line)`,
+    durationMs: 0,
+  }
+}
+
+/** The stack line says how the stack was decided: by lock file, by manifest alone, none, or several lock files and so every stack's markers. */
+export const stackLine = (detection: StackDetection): string => {
+  if (detection.kind === 'found') return `Stack: ${detection.stack}`
+  if (detection.kind === 'manifest') return `Stack: ${detection.stack} (from ${detection.manifest}, no lock file yet)`
+  if (detection.kind === 'none')
+    return 'Stack: none detected (no lock file of a known stack, no manifest of a single stack)'
+  return `Stack: ambiguous (lock files of several stacks: ${detection.lockFiles.join(', ')}), checking with every stack's markers`
+}
+
+export const formatPlanHeader = (
+  files: readonly ChangedFile[],
+  plan: CheckPlan,
+  detection: StackDetection,
+): string[] => [
   `Changed files (${files.length}, ${files.filter((file) => file.staged).length} staged):`,
   ...files.map((file) => `   ${file.staged ? 'S' : ' '} ${file.path}`),
   '',
+  stackLine(detection),
   `Package roots: ${plan.roots.join(', ') || 'none'}`,
   `Reviewers: ${plan.reviewers.join(', ') || 'none'}`,
   ...(plan.generated.length > 0

package/src/check/result.ts

@@ -1,5 +1,7 @@
-import type { PlannedCheck } from './plan'
-import { CHECK_KIND } from './plan'
+/** What a planned check is; `types` and `tests` are the slow ones, and a project check may stand in for either. */
+export const CHECK_KIND = { lint: 'lint', project: 'project', types: 'types', tests: 'tests' } as const
+
+export type CheckKind = (typeof CHECK_KIND)[keyof typeof CHECK_KIND]
 
 /** `warn` reports a finding without failing the run. */
 export const CHECK_STATUS = { pass: 'pass', fail: 'fail', warn: 'warn', skipped: 'skipped' } as const
@@ -18,6 +20,14 @@ export type ProcessResult = { ok: boolean; output: string }
 
 export const SKIP_SLOW_FLAG = '--skip-slow'
 
+/** `quick` leaves every type check and test out (`--skip-slow`); `full` runs them. */
+export const RUN_MODE = { full: 'full', quick: 'quick' } as const
+
+export type RunMode = (typeof RUN_MODE)[keyof typeof RUN_MODE]
+
+export const runModeOf = (args: readonly string[]): RunMode =>
+  args.includes(SKIP_SLOW_FLAG) ? RUN_MODE.quick : RUN_MODE.full
+
 /**
  * Bun reports "there was nothing to run" in two shapes: a package whose files hold no test cases
  * summarises as `0 tests`, one with no matching files exits non-zero with `0 test files matching`.
@@ -30,7 +40,7 @@ export const lastLines = (output: string, count: number): string =>
 
 /** How a finished process reads for its check: an absent test suite is skipped, not failed. */
 export const outcomeOf = (
-  check: PlannedCheck,
+  check: { kind: CheckKind },
   { ok, output }: ProcessResult,
 ): Pick<CheckResult, 'status' | 'detail'> => {
   if (check.kind === CHECK_KIND.tests && reportsNoTests(output)) {