@beignet/cli 0.0.51 → 0.0.52

package/src/analysis/source-files.ts

@@ -0,0 +1,61 @@
+import path from "node:path";
+import ts from "typescript";
+
+export const typescriptAnalysisSourceFileExtensions = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+] as const;
+
+export const javascriptAnalysisSourceFileExtensions = [
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+] as const;
+
+export const analysisSourceFileExtensions = [
+  ...typescriptAnalysisSourceFileExtensions,
+  ...javascriptAnalysisSourceFileExtensions,
+] as const;
+
+const sourceFileExtensions = new Set<string>(analysisSourceFileExtensions);
+const javascriptSourceFileExtensions = new Set<string>(
+  javascriptAnalysisSourceFileExtensions,
+);
+const declarationFilePattern = /\.d\.(?:ts|mts|cts)$/;
+
+/** Whether an extension belongs to the JavaScript/TypeScript source family. */
+export function isAnalysisSourceFileExtension(extension: string): boolean {
+  return sourceFileExtensions.has(extension);
+}
+
+/** Whether a project file can participate in Beignet source analysis. */
+export function isAnalysisSourceFile(file: string): boolean {
+  return (
+    isAnalysisSourceFileExtension(path.posix.extname(file)) &&
+    !declarationFilePattern.test(file)
+  );
+}
+
+/** Remove a JavaScript or TypeScript source extension from a path. */
+export function stripSourceFileExtension(file: string): string {
+  const extension = path.posix.extname(file);
+  return isAnalysisSourceFileExtension(extension)
+    ? file.slice(0, -extension.length)
+    : file;
+}
+
+/** Whether a source file uses JavaScript rather than TypeScript syntax. */
+export function isJavaScriptSourceFile(file: string): boolean {
+  return javascriptSourceFileExtensions.has(path.posix.extname(file));
+}
+
+/** Select the TypeScript parser mode for a JavaScript or TypeScript file. */
+export function sourceFileScriptKind(file: string): ts.ScriptKind {
+  if (file.endsWith(".tsx")) return ts.ScriptKind.TSX;
+  if (file.endsWith(".jsx")) return ts.ScriptKind.JSX;
+  if (isJavaScriptSourceFile(file)) return ts.ScriptKind.JS;
+  return ts.ScriptKind.TS;
+}

package/src/analysis/workspace.ts

@@ -8,6 +8,10 @@ import {
   type ResolvedBeignetConfig,
   resolveConfig,
 } from "../config.js";
+import {
+  isAnalysisSourceFileExtension,
+  sourceFileScriptKind,
+} from "./source-files.js";
 
 const ignoredDirectoryNames = new Set([
   ".git",
@@ -84,7 +88,7 @@ export async function createAnalysisWorkspace(
         await readSource(file),
         ts.ScriptTarget.Latest,
         true,
-        scriptKind(file),
+        sourceFileScriptKind(file),
       );
       sourceFiles.set(file, sourceFile);
       return sourceFile;
@@ -208,12 +212,7 @@ export function isLocalModuleSpecifier(
   importPath: string,
 ): boolean {
   const extension = path.posix.extname(importPath);
-  if (
-    extension &&
-    ![".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"].includes(
-      extension,
-    )
-  ) {
+  if (extension && !isAnalysisSourceFileExtension(extension)) {
     return false;
   }
   if (importPath.startsWith(".")) return true;
@@ -298,28 +297,32 @@ function resolveCompilerConfiguration(targetDir: string): {
   compilerOptions: ts.CompilerOptions;
 } {
   const compilerConfigFiles = new Set<string>();
-  const configPath = path.join(targetDir, "tsconfig.json");
-  const compilerOptions =
-    ts.getParsedCommandLineOfConfigFile(
-      configPath,
-      {},
-      {
-        ...ts.sys,
-        readFile(file) {
-          compilerConfigFiles.add(path.resolve(file));
-          return ts.sys.readFile(file);
+  const configPath = ["tsconfig.json", "jsconfig.json"]
+    .map((file) => path.join(targetDir, file))
+    .find(ts.sys.fileExists);
+  const compilerOptions = configPath
+    ? (ts.getParsedCommandLineOfConfigFile(
+        configPath,
+        {},
+        {
+          ...ts.sys,
+          readFile(file) {
+            compilerConfigFiles.add(path.resolve(file));
+            return ts.sys.readFile(file);
+          },
+          onUnRecoverableConfigFileDiagnostic: () => {},
         },
-        onUnRecoverableConfigFileDiagnostic: () => {},
-      },
-    )?.options ?? {};
+      )?.options ?? {})
+    : {};
+  const analysisOptions = { ...compilerOptions, allowJs: true };
 
   return {
     compilerConfigFiles: [...compilerConfigFiles].sort(),
-    compilerOptions: compilerOptions.paths
-      ? compilerOptions
+    compilerOptions: analysisOptions.paths
+      ? analysisOptions
       : {
-          ...compilerOptions,
-          baseUrl: compilerOptions.baseUrl ?? targetDir,
+          ...analysisOptions,
+          baseUrl: analysisOptions.baseUrl ?? targetDir,
           paths: {
             "@/*": ["*"],
           },
@@ -338,10 +341,3 @@ function compilerPathsBase(
     compilerOptions.baseUrl ?? optionsWithPathBase.pathsBasePath ?? targetDir
   );
 }
-
-function scriptKind(file: string): ts.ScriptKind {
-  if (file.endsWith(".tsx")) return ts.ScriptKind.TSX;
-  if (file.endsWith(".jsx")) return ts.ScriptKind.JSX;
-  if (file.endsWith(".js") || file.endsWith(".mjs")) return ts.ScriptKind.JS;
-  return ts.ScriptKind.TS;
-}

package/src/app-map-changes.ts

@@ -1,5 +1,9 @@
 import { readFile, realpath } from "node:fs/promises";
 import path from "node:path";
+import {
+  isAnalysisSourceFile,
+  stripSourceFileExtension,
+} from "./analysis/source-files.js";
 import {
   type LocalImportReference,
   localImportReferences,
@@ -794,7 +798,7 @@ async function addImportConsumers(args: {
       reference: LocalImportReference;
     }>
   >();
-  const sourceFiles = args.workspace.files.filter(isSourceFile);
+  const sourceFiles = args.workspace.files.filter(isAnalysisSourceFile);
   await Promise.all(
     sourceFiles.map(async (file) => {
       for (const reference of await localImportReferences(
@@ -826,7 +830,9 @@ async function addImportConsumers(args: {
     );
   }
 
-  for (const change of args.changes.filter((item) => isSourceFile(item.file))) {
+  for (const change of args.changes.filter((item) =>
+    isAnalysisSourceFile(item.file),
+  )) {
     const queue: Array<{
       confidence: "exact" | "partial";
       depth: number;
@@ -1002,7 +1008,7 @@ function addUnmappedChangeGaps(args: {
     const represented = reasons.some(
       (reason) => reason.changedFile === change.repositoryPath,
     );
-    const sourceFile = isSourceFile(change.file);
+    const sourceFile = isAnalysisSourceFile(change.file);
     if (sourceFile && change.status === "deleted") {
       args.gaps.push({
         code: "deleted_source_unresolved",
@@ -1289,7 +1295,7 @@ function scopeSort(scope: AppChangeFileScope): number {
 }
 
 function moduleStem(file: string): string {
-  return normalizePath(file).replace(/\.(?:c|m)?[jt]sx?$/, "");
+  return stripSourceFileExtension(normalizePath(file));
 }
 
 function resolvedModuleKey(file: string): string {
@@ -1333,10 +1339,6 @@ function highestPriorityScope(
   );
 }
 
-function isSourceFile(file: string): boolean {
-  return /\.(?:c|m)?[jt]sx?$/.test(file) && !file.endsWith(".d.ts");
-}
-
 function isDocumentationPath(file: string, roots: string[]): boolean {
   const normalized = normalizePath(file);
   const basename = path.posix.basename(normalized);

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,