@beignet/cli 0.0.50 → 0.0.52

package/src/app-map.ts

@@ -6,6 +6,10 @@ import {
   isImportedContractDeclaration,
 } from "./analysis/contract-factories.js";
 import { analyzePortWiring } from "./analysis/port-wiring.js";
+import {
+  isAnalysisSourceFile,
+  stripSourceFileExtension,
+} from "./analysis/source-files.js";
 import {
   createSourceIndex,
   exportedVariableDeclarations,
@@ -29,6 +33,11 @@ import {
 } from "./inspect.js";
 import { type LintDiagnostic, lintApp } from "./lint.js";
 import { auditProviders } from "./provider-audit.js";
+import {
+  appTestRoots,
+  isAppTestFile,
+  isWithinAppTestRoots,
+} from "./test-discovery.js";
 
 export type { AppMapNodeKind } from "./app-map-schema.js";
 export { appMapNodeKinds } from "./app-map-schema.js";
@@ -208,6 +217,7 @@ export async function mapApp(
   const registries: RegistryRecord[] = [];
   const featuresPath = directoryPath(workspace.config.paths.features);
   const featureNames = discoverFeatureNames(workspace, featuresPath);
+  const testRoots = appTestRoots(workspace.config.paths);
 
   const addNode = (node: AppMapNode) => {
     const existing = nodes.get(node.id);
@@ -241,17 +251,23 @@ export async function mapApp(
       status: "declared",
       details: roles,
     });
+  }
 
-    for (const file of featureFiles.filter(isTestFile)) {
-      const id = `test:${file}`;
-      addNode({
-        id,
-        kind: "test",
-        name: path.posix.basename(file),
-        feature,
-        source: { file },
-        status: "declared",
-      });
+  for (const file of workspace.files.filter(
+    (candidate) =>
+      isAppTestFile(candidate) && isWithinAppTestRoots(candidate, testRoots),
+  )) {
+    const id = `test:${file}`;
+    const feature = featureForFile(file, featuresPath);
+    addNode({
+      id,
+      kind: "test",
+      name: path.posix.basename(file),
+      ...(feature ? { feature } : {}),
+      source: { file },
+      status: "declared",
+    });
+    if (feature) {
       addEdge(exactEdge("contains-test", featureId(feature), id, file));
     }
   }
@@ -345,7 +361,7 @@ export async function mapApp(
       details: { type: "server" },
     });
   }
-  const sourceFiles = workspace.files.filter(isTypeScriptSource);
+  const sourceFiles = workspace.files.filter(isAnalysisSourceFile);
   for (const file of sourceFiles) {
     const sourceFile = await workspace.readSourceFile(file);
     for (const { exportName, declaration } of exportedVariableDeclarations(
@@ -918,7 +934,8 @@ async function addRouteGroups(args: {
   const routeFiles = args.workspace.files.filter(
     (file) =>
       featureForFile(file, args.featuresPath) !== undefined &&
-      file.endsWith("/routes.ts"),
+      isAnalysisSourceFile(file) &&
+      stripSourceFileExtension(file).endsWith("/routes"),
   );
 
   for (const file of routeFiles) {
@@ -1192,8 +1209,8 @@ async function addOutboxDeliveryGraph(args: {
   ]);
   for (const file of args.workspace.files) {
     if (
-      !isTypeScriptSource(file) ||
-      isTestFile(file) ||
+      !isAnalysisSourceFile(file) ||
+      isAppTestFile(file) ||
       ![...runtimeDirectories].some(
         (directory) =>
           directory === "." ||
@@ -1276,9 +1293,10 @@ function isProviderLifecycleSource(
   file: string,
   sourceFile: ts.SourceFile,
 ): boolean {
+  const sourcePath = stripSourceFileExtension(file);
   if (
-    /(^|\/)provider(s)?\.ts$/.test(file) ||
-    /(^|\/)[^/]*provider[^/]*\.ts$/.test(file) ||
+    /(^|\/)provider(s)?$/.test(sourcePath) ||
+    /(^|\/)[^/]*provider[^/]*$/.test(sourcePath) ||
     /(^|\/)providers?\//.test(file)
   ) {
     return true;
@@ -1390,7 +1408,7 @@ async function addTables(args: {
   const schemaPrefix = `${infraDir}/db/schema/`;
   const files = args.workspace.files.filter(
     (file) =>
-      isTypeScriptSource(file) &&
+      isAnalysisSourceFile(file) &&
       (file.startsWith(schemaPrefix) ||
         schemaSources.some((source) =>
           file.startsWith(staticPathPrefix(source)),
@@ -1447,7 +1465,7 @@ async function addFeatureDependencies(args: {
     }
   >();
 
-  for (const file of args.workspace.files.filter(isTypeScriptSource)) {
+  for (const file of args.workspace.files.filter(isAnalysisSourceFile)) {
     const from = featureForFile(file, args.featuresPath);
     if (!from || !args.featureNames.has(from)) continue;
     for (const reference of await localImportReferences(args.workspace, file)) {
@@ -1496,7 +1514,7 @@ async function addUnresolvedLocalImports(args: {
   workspace: AnalysisWorkspace;
   unresolved: AppMapUnresolvedReference[];
 }): Promise<void> {
-  for (const file of args.workspace.files.filter(isTypeScriptSource)) {
+  for (const file of args.workspace.files.filter(isAnalysisSourceFile)) {
     for (const reference of await localImportReferences(args.workspace, file)) {
       if (reference.resolvedFile) continue;
       args.unresolved.push({
@@ -1556,15 +1574,16 @@ function appMapContractSourceFiles(workspace: AnalysisWorkspace): string[] {
     contractsPath === directoryPath(workspace.config.paths.features);
 
   return workspace.files.filter((file) => {
-    if (!file.endsWith(".ts") || file.endsWith(".test.ts")) return false;
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) return false;
+    const sourcePath = stripSourceFileExtension(file);
     if (featureOwned) {
       const prefix = `${contractsPath}/`;
       if (!file.startsWith(prefix)) return false;
-      const parts = file.slice(prefix.length).split("/");
-      return parts.length === 2 && parts[1] === "contracts.ts";
+      const parts = sourcePath.slice(prefix.length).split("/");
+      return parts.length === 2 && parts[1] === "contracts";
     }
     return (
-      file === `${contractsPath}.ts` || file.startsWith(`${contractsPath}/`)
+      sourcePath === contractsPath || sourcePath.startsWith(`${contractsPath}/`)
     );
   });
 }
@@ -1824,7 +1843,7 @@ function summarizeFeatureFiles(files: string[]): Record<string, number> {
     client: files.filter((file) => file.includes("/client/")).length,
     components: files.filter((file) => file.includes("/components/")).length,
     domain: files.filter((file) => file.includes("/domain/")).length,
-    tests: files.filter(isTestFile).length,
+    tests: files.filter(isAppTestFile).length,
   };
 }
 
@@ -2017,14 +2036,6 @@ function sourceNodeEdge(
   };
 }
 
-function isTestFile(file: string): boolean {
-  return /\.(test|spec)\.(ts|tsx|mts|cts)$/.test(file);
-}
-
-function isTypeScriptSource(file: string): boolean {
-  return /\.(ts|tsx|mts|cts)$/.test(file) && !file.endsWith(".d.ts");
-}
-
 function staticPathPrefix(pattern: string): string {
   const wildcard = pattern.search(/[?*[{]/);
   return wildcard === -1 ? pattern : pattern.slice(0, wildcard);

package/src/check.ts

@@ -1,7 +1,11 @@
-import { readdir, readFile, stat } from "node:fs/promises";
+import { readdir, readFile, realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import { createPainter } from "./ansi.js";
 import { detectPackageManager, spawnCommand } from "./db.js";
+import {
+  type GitSourceSnapshot,
+  readGitSourceSnapshot,
+} from "./git-changes.js";
 import {
   applyDoctorFixes,
   formatDoctor,
@@ -33,6 +37,14 @@ export type CheckAppResult = {
   ok: boolean;
   fixes: InspectFix[];
   steps: CheckStep[];
+  provenance: CheckProvenance;
+};
+
+/** Source-state evidence captured around one complete check run. */
+export type CheckProvenance = {
+  status: "current" | "stale" | "unavailable";
+  start: GitSourceSnapshot;
+  end: GitSourceSnapshot;
 };
 
 export type CheckAppOptions = {
@@ -74,19 +86,34 @@ const defaultMaxOutputBytes = 64 * 1024;
 export async function checkApp(
   options: CheckAppOptions = {},
 ): Promise<CheckAppResult> {
-  const targetDir = path.resolve(options.cwd ?? process.cwd());
-  const scripts = await readAppPackageScripts(targetDir);
-  const runner = await detectPackageManager(targetDir);
+  options.signal?.throwIfAborted();
+  const targetDir = await resolveCheckTargetDir(options.cwd ?? process.cwd());
+  options.signal?.throwIfAborted();
+  // Validate the app root before fixes may write; reload execution metadata
+  // after the provenance baseline so the selected scripts are covered by it.
+  await readAppPackageScripts(targetDir);
+  options.signal?.throwIfAborted();
+  const fixes = options.fix
+    ? await applyDoctorFixes({ cwd: targetDir, strict: true })
+    : [];
+  options.signal?.throwIfAborted();
   const steps: CheckStep[] = [];
   const record = (step: CheckStep): void => {
     steps.push(step);
     options.onStep?.(step);
   };
 
+  const start = await readGitSourceSnapshot({
+    cwd: targetDir,
+    signal: options.signal,
+  });
+  options.signal?.throwIfAborted();
+  const scripts = await readAppPackageScripts(targetDir);
+  const runner = await detectPackageManager(targetDir);
   options.signal?.throwIfAborted();
   record(await lintStep(targetDir, options));
   options.signal?.throwIfAborted();
-  const { step: doctorStep, fixes } = await runDoctorStep(targetDir, options);
+  const doctorStep = await runDoctorStep(targetDir, options, fixes);
   record(doctorStep);
 
   if (options.preflight || options.preflightConnect) {
@@ -105,16 +132,38 @@ export async function checkApp(
     record(await scriptStep(targetDir, runner, script, scripts, options));
   }
 
+  options.signal?.throwIfAborted();
+  const end = await readGitSourceSnapshot({
+    cwd: targetDir,
+    signal: options.signal,
+  });
+  options.signal?.throwIfAborted();
+  const provenance = checkProvenance(start, end);
+
   return {
     schemaVersion: 1,
     targetDir,
     runner,
-    ok: steps.every((step) => step.status !== "failed"),
+    ok:
+      steps.every((step) => step.status !== "failed") &&
+      provenance.status !== "stale",
     fixes,
     steps,
+    provenance,
   };
 }
 
+async function resolveCheckTargetDir(cwd: string): Promise<string> {
+  const targetDir = path.resolve(cwd);
+  try {
+    return await realpath(targetDir);
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === "ENOENT" || code === "ENOTDIR") return targetDir;
+    throw error;
+  }
+}
+
 /**
  * Format a completed step as a single status line, with the failing step's
  * output indented underneath.
@@ -161,9 +210,35 @@ export function formatCheckSummary(
   const parts = [`${counts.passed} passed`];
   if (counts.failed > 0) parts.push(paint(`${counts.failed} failed`, "red"));
   if (counts.skipped > 0) parts.push(`${counts.skipped} skipped`);
+  if (result.provenance.status === "stale") {
+    parts.push(paint("source state stale", "red"));
+  }
   return parts.join(", ");
 }
 
+/** Format the source state captured before and after validation. */
+export function formatCheckProvenance(
+  result: CheckAppResult,
+  options: { color?: boolean } = {},
+): string {
+  const paint = createPainter(options.color);
+  const { provenance } = result;
+  if (provenance.status === "unavailable") {
+    return `${paint("-", "cyan")} Source provenance unavailable (not a Git worktree)`;
+  }
+  if (provenance.status === "stale") {
+    return `${paint("✗", "red")} Source state changed while checks were running; rerun beignet check`;
+  }
+  const snapshot = provenance.end;
+  if (snapshot.kind !== "git") {
+    throw new Error("Current check provenance must contain a Git snapshot.");
+  }
+  const head = snapshot.comparison.head
+    ? `HEAD ${snapshot.comparison.head.slice(0, 8)}`
+    : "unborn Git repository";
+  return `${paint("✓", "green")} Source state current (${head}, ${shortHash(snapshot.repositoryChangeHash)})`;
+}
+
 /**
  * Format a full result at once (JSON-free callers and tests).
  */
@@ -172,6 +247,7 @@ export function formatCheck(
   options: { color?: boolean } = {},
 ): string {
   const lines = result.steps.map((step) => formatCheckStep(step, options));
+  lines.push(formatCheckProvenance(result, options));
   return `${lines.join("\n")}\n\n${formatCheckSummary(result, options)}`;
 }
 
@@ -195,11 +271,9 @@ async function lintStep(
 async function runDoctorStep(
   targetDir: string,
   options: CheckAppOptions,
-): Promise<{ step: CheckStep; fixes: InspectFix[] }> {
+  fixes: InspectFix[],
+): Promise<CheckStep> {
   const startedAt = Date.now();
-  const fixes = options.fix
-    ? await applyDoctorFixes({ cwd: targetDir, strict: true })
-    : [];
   const result = await inspectApp({ cwd: targetDir, strict: true });
   result.fixes = fixes;
   const failed = result.diagnostics.some(
@@ -208,24 +282,40 @@ async function runDoctorStep(
   );
 
   return {
-    step: {
-      name: "beignet doctor --strict",
-      command: "beignet doctor --strict",
-      status: failed ? "failed" : "passed",
-      ...(fixes.length > 0
-        ? {
-            detail: `${fixes.length} ${fixes.length === 1 ? "fix" : "fixes"} applied`,
-          }
-        : {}),
-      ...(failed
-        ? { output: formatDoctor(result, { color: options.color }) }
-        : {}),
-      durationMs: Date.now() - startedAt,
-    },
-    fixes,
+    name: "beignet doctor --strict",
+    command: "beignet doctor --strict",
+    status: failed ? "failed" : "passed",
+    ...(fixes.length > 0
+      ? {
+          detail: `${fixes.length} ${fixes.length === 1 ? "fix" : "fixes"} applied`,
+        }
+      : {}),
+    ...(failed
+      ? { output: formatDoctor(result, { color: options.color }) }
+      : {}),
+    durationMs: Date.now() - startedAt,
   };
 }
 
+function checkProvenance(
+  start: GitSourceSnapshot,
+  end: GitSourceSnapshot,
+): CheckProvenance {
+  if (start.kind === "unavailable" && end.kind === "unavailable") {
+    return { status: "unavailable", start, end };
+  }
+  const current =
+    start.kind === "git" &&
+    end.kind === "git" &&
+    start.repositoryRoot === end.repositoryRoot &&
+    start.repositoryChangeHash === end.repositoryChangeHash;
+  return { status: current ? "current" : "stale", start, end };
+}
+
+function shortHash(hash: string): string {
+  return `${hash.slice(0, 15)}…`;
+}
+
 async function scriptStep(
   targetDir: string,
   runner: string,