@beignet/cli 0.0.51 → 0.0.53

package/src/analysis/workspace.ts

@@ -1,4 +1,4 @@
-import { readdir, readFile, stat } from "node:fs/promises";
+import { readdir, readFile, realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import ts from "typescript";
 import {
@@ -8,6 +8,11 @@ import {
   type ResolvedBeignetConfig,
   resolveConfig,
 } from "../config.js";
+import {
+  isAnalysisSourceFile,
+  isAnalysisSourceFileExtension,
+  sourceFileScriptKind,
+} from "./source-files.js";
 
 const ignoredDirectoryNames = new Set([
   ".git",
@@ -18,8 +23,23 @@ const ignoredDirectoryNames = new Set([
   "node_modules",
 ]);
 
+export type AnalysisProject = {
+  targetDir: string;
+  canonicalDir: string;
+  prefix: string;
+  name?: string;
+  dependencies: Set<string>;
+  localDependencies: Set<string>;
+  config: ResolvedBeignetConfig;
+  files: string[];
+  compilerOptions: ts.CompilerOptions;
+  compilerConfigFiles: string[];
+  moduleResolutionCache: ts.ModuleResolutionCache;
+};
+
 export type AnalysisWorkspace = {
   targetDir: string;
+  projects: AnalysisProject[];
   files: string[];
   fileSet: Set<string>;
   config: ResolvedBeignetConfig;
@@ -40,24 +60,70 @@ export async function createAnalysisWorkspace(
 ): Promise<AnalysisWorkspace> {
   const targetDir = path.resolve(cwd);
   await assertDirectory(targetDir);
-  const files = await listProjectFiles(targetDir);
-  const fileSet = new Set(files);
+  const appFiles = await listProjectFiles(targetDir);
   const config = options.config
     ? resolveConfig(options.config)
-    : await loadBeignetConfig(targetDir, files);
-  const { compilerConfigFiles, compilerOptions } =
-    resolveCompilerConfiguration(targetDir);
-  const moduleResolutionCache = ts.createModuleResolutionCache(
-    targetDir,
-    ts.sys.useCaseSensitiveFileNames
-      ? (fileName) => fileName
-      : (fileName) => fileName.toLowerCase(),
-    compilerOptions,
-  );
+    : await loadBeignetConfig(targetDir, appFiles);
+  const app = await createProject(targetDir, targetDir, appFiles, config);
+  const projects = [app];
+  for (const directory of config.workspace.packages) {
+    const packageDir = path.resolve(targetDir, directory);
+    await assertDirectory(packageDir);
+    const canonical = await realpath(packageDir);
+    for (const project of projects) {
+      const existing = project.canonicalDir;
+      if (within(canonical, existing) || within(existing, canonical)) {
+        throw new Error(
+          `Workspace package ${directory} overlaps ${project.prefix || "the app"}. Package roots must be separate directories.`,
+        );
+      }
+    }
+    const packageFiles = await listProjectFiles(packageDir);
+    const packageConfig = await loadBeignetConfig(packageDir, packageFiles);
+    const project = await createProject(
+      targetDir,
+      packageDir,
+      packageFiles,
+      packageConfig,
+    );
+    if (!project.name)
+      throw new Error(
+        `Workspace package ${directory} must have a name in package.json.`,
+      );
+    if (projects.some((candidate) => candidate.name === project.name)) {
+      throw new Error(`Duplicate workspace package name ${project.name}.`);
+    }
+    projects.push(project);
+  }
+  const reachable = new Set([app]);
+  for (const project of reachable) {
+    for (const candidate of projects.slice(1)) {
+      if (candidate.name && project.dependencies.has(candidate.name))
+        reachable.add(candidate);
+    }
+  }
+  for (const project of projects.slice(1)) {
+    if (!reachable.has(project))
+      throw new Error(
+        `Workspace package ${project.name} is not a declared dependency of the app or its configured source packages.`,
+      );
+  }
+  const files = projects
+    .flatMap((project) =>
+      project.files.map((file) => projectPath(project, file)),
+    )
+    .sort();
+  const fileSet = new Set(files);
+  const { compilerOptions, moduleResolutionCache } = app;
+  const compilerConfigFiles = [
+    ...new Set(projects.flatMap((project) => project.compilerConfigFiles)),
+  ].sort();
   const sources = new Map<string, string>();
   const sourceFiles = new Map<string, ts.SourceFile>();
 
   const readSource = async (file: string): Promise<string> => {
+    if (!fileSet.has(file))
+      throw new Error(`Source file is outside the analysis workspace: ${file}`);
     const cached = sources.get(file);
     if (cached !== undefined) return cached;
 
@@ -68,6 +134,7 @@ export async function createAnalysisWorkspace(
 
   return {
     targetDir,
+    projects,
     files,
     fileSet,
     config,
@@ -84,7 +151,7 @@ export async function createAnalysisWorkspace(
         await readSource(file),
         ts.ScriptTarget.Latest,
         true,
-        scriptKind(file),
+        sourceFileScriptKind(file),
       );
       sourceFiles.set(file, sourceFile);
       return sourceFile;
@@ -132,7 +199,11 @@ export async function listProjectFiles(targetDir: string): Promise<string[]> {
 export function resolveLocalSourceFile(
   workspace: Pick<
     AnalysisWorkspace,
-    "compilerOptions" | "fileSet" | "moduleResolutionCache" | "targetDir"
+    | "compilerOptions"
+    | "fileSet"
+    | "moduleResolutionCache"
+    | "targetDir"
+    | "projects"
   >,
   importerFile: string,
   importPath: string,
@@ -143,14 +214,36 @@ export function resolveLocalSourceFile(
   const file = normalizePath(
     path.relative(workspace.targetDir, resolved.resolvedFileName),
   );
-  if (file === ".." || file.startsWith("../")) return undefined;
-  return workspace.fileSet.has(file) ? file : undefined;
+  if (
+    workspace.fileSet.has(file) &&
+    (!projectForFile(workspace, file).prefix || isAnalysisSourceFile(file))
+  )
+    return file;
+  const canonicalFile =
+    ts.sys.realpath?.(resolved.resolvedFileName) ?? resolved.resolvedFileName;
+  for (const project of workspace.projects) {
+    if (!within(canonicalFile, project.canonicalDir)) continue;
+    const candidate = projectPath(
+      project,
+      path.relative(project.canonicalDir, canonicalFile),
+    );
+    if (
+      workspace.fileSet.has(candidate) &&
+      (!project.prefix || isAnalysisSourceFile(candidate))
+    )
+      return candidate;
+  }
+  return undefined;
 }
 
 export function resolveLocalModulePath(
   workspace: Pick<
     AnalysisWorkspace,
-    "compilerOptions" | "fileSet" | "moduleResolutionCache" | "targetDir"
+    | "compilerOptions"
+    | "fileSet"
+    | "moduleResolutionCache"
+    | "targetDir"
+    | "projects"
   >,
   importerFile: string,
   importPath: string,
@@ -166,16 +259,34 @@ export function resolveLocalModulePath(
     return undefined;
   }
 
+  const project = projectForFile(workspace, importerFile);
+  if (
+    workspace.projects.length > 1 &&
+    (importPath.startsWith(".") ||
+      importPath.startsWith("#") ||
+      Object.keys(project.compilerOptions.paths ?? {}).some(
+        (pattern) =>
+          pattern !== "*" && modulePatternMatches(pattern, importPath),
+      ))
+  ) {
+    const resolved = resolveModule(workspace, importerFile, importPath);
+    if (resolved)
+      return normalizePath(
+        path.relative(
+          workspace.targetDir,
+          ts.sys.realpath?.(resolved.resolvedFileName) ??
+            resolved.resolvedFileName,
+        ),
+      );
+  }
+
   if (importPath.startsWith(".")) {
     return normalizePath(path.join(path.dirname(importerFile), importPath));
   }
 
-  const baseUrl = compilerPathsBase(
-    workspace.compilerOptions,
-    workspace.targetDir,
-  );
+  const baseUrl = compilerPathsBase(project.compilerOptions, project.targetDir);
   for (const [pattern, targets] of Object.entries(
-    workspace.compilerOptions.paths ?? {},
+    project.compilerOptions.paths ?? {},
   )) {
     if (pattern === "*") continue;
     const wildcardValue = modulePatternWildcard(pattern, importPath);
@@ -187,14 +298,22 @@ export function resolveLocalModulePath(
       const relative = normalizePath(
         path.relative(workspace.targetDir, absolute),
       );
-      if (relative !== ".." && !relative.startsWith("../")) return relative;
+      if (
+        workspace.projects.length > 1 ||
+        workspace.projects.some((candidate) =>
+          within(absolute, candidate.targetDir),
+        )
+      )
+        return relative;
     }
   }
 
   const relative = normalizePath(
     path.relative(workspace.targetDir, path.resolve(baseUrl, importPath)),
   );
-  return relative !== ".." && !relative.startsWith("../")
+  return workspace.projects.some((candidate) =>
+    within(path.resolve(workspace.targetDir, relative), candidate.targetDir),
+  )
     ? relative
     : undefined;
 }
@@ -202,17 +321,20 @@ export function resolveLocalModulePath(
 export function isLocalModuleSpecifier(
   workspace: Pick<
     AnalysisWorkspace,
-    "compilerOptions" | "fileSet" | "moduleResolutionCache" | "targetDir"
+    | "compilerOptions"
+    | "fileSet"
+    | "moduleResolutionCache"
+    | "targetDir"
+    | "projects"
   >,
   importerFile: string,
   importPath: string,
 ): boolean {
   const extension = path.posix.extname(importPath);
   if (
+    !importPath.startsWith("#") &&
     extension &&
-    ![".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"].includes(
-      extension,
-    )
+    !isAnalysisSourceFileExtension(extension)
   ) {
     return false;
   }
@@ -223,12 +345,33 @@ export function isLocalModuleSpecifier(
     const file = normalizePath(
       path.relative(workspace.targetDir, resolved.resolvedFileName),
     );
-    return (
-      file !== ".." && !file.startsWith("../") && workspace.fileSet.has(file)
-    );
+    if (
+      workspace.fileSet.has(file) ||
+      resolveLocalSourceFile(workspace, importerFile, importPath)
+    )
+      return true;
+    // Package-import aliases can resolve to an omitted workspace through an
+    // install symlink. Keep normal dependencies inside node_modules external.
+    const canonical =
+      ts.sys.realpath?.(resolved.resolvedFileName) ?? resolved.resolvedFileName;
+    if (
+      importPath.startsWith("#") &&
+      !normalizePath(canonical).split("/").includes("node_modules")
+    )
+      return true;
   }
 
-  const pathPatterns = Object.keys(workspace.compilerOptions.paths ?? {});
+  const project = projectForFile(workspace, importerFile);
+  if (
+    workspace.projects.some(
+      (candidate) =>
+        candidate.name &&
+        (importPath === candidate.name ||
+          importPath.startsWith(`${candidate.name}/`)),
+    )
+  )
+    return true;
+  const pathPatterns = Object.keys(project.compilerOptions.paths ?? {});
   if (
     pathPatterns.some(
       (pattern) =>
@@ -240,7 +383,7 @@ export function isLocalModuleSpecifier(
     return true;
   }
 
-  const baseUrl = workspace.compilerOptions.baseUrl;
+  const baseUrl = project.compilerOptions.baseUrl;
   if (!baseUrl) return false;
   const firstSegment = importPath.split("/")[0];
   const prefix = normalizePath(
@@ -255,17 +398,18 @@ export function isLocalModuleSpecifier(
 function resolveModule(
   workspace: Pick<
     AnalysisWorkspace,
-    "compilerOptions" | "moduleResolutionCache" | "targetDir"
+    "compilerOptions" | "moduleResolutionCache" | "targetDir" | "projects"
   >,
   importerFile: string,
   importPath: string,
 ): ts.ResolvedModuleFull | undefined {
+  const project = projectForFile(workspace, importerFile);
   return ts.resolveModuleName(
     importPath,
     path.join(workspace.targetDir, importerFile),
-    workspace.compilerOptions,
+    project.compilerOptions,
     ts.sys,
-    workspace.moduleResolutionCache,
+    project.moduleResolutionCache,
   ).resolvedModule;
 }
 
@@ -298,28 +442,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: {
             "@/*": ["*"],
           },
@@ -339,9 +487,104 @@ function compilerPathsBase(
   );
 }
 
-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;
+async function createProject(
+  appDir: string,
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+): Promise<AnalysisProject> {
+  const manifest: unknown = files.includes("package.json")
+    ? JSON.parse(await readFile(path.join(targetDir, "package.json"), "utf8"))
+    : {};
+  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+    throw new Error(`Invalid package.json in ${targetDir}.`);
+  }
+  const data = manifest as Record<string, unknown>;
+  const dependencies = new Set<string>();
+  const localDependencies = new Set<string>();
+  for (const key of [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+  ]) {
+    const value = data[key];
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      for (const [name, specifier] of Object.entries(value)) {
+        dependencies.add(name);
+        if (
+          typeof specifier === "string" &&
+          /^(workspace|link|file):/.test(specifier) &&
+          !specifier.endsWith(".tgz")
+        )
+          localDependencies.add(name);
+      }
+    }
+  }
+  const { compilerConfigFiles, compilerOptions } =
+    resolveCompilerConfiguration(targetDir);
+  return {
+    targetDir,
+    canonicalDir: await realpath(targetDir),
+    prefix: normalizePath(path.relative(appDir, targetDir)),
+    ...(typeof data.name === "string" && data.name.trim()
+      ? { name: data.name }
+      : {}),
+    dependencies,
+    localDependencies,
+    config,
+    files,
+    compilerConfigFiles,
+    compilerOptions,
+    moduleResolutionCache: ts.createModuleResolutionCache(
+      targetDir,
+      ts.sys.useCaseSensitiveFileNames
+        ? (file) => file
+        : (file) => file.toLowerCase(),
+      compilerOptions,
+    ),
+  };
+}
+
+export function projectForFile(
+  workspace: Pick<AnalysisWorkspace, "projects" | "targetDir">,
+  file: string,
+): AnalysisProject {
+  return findProjectForFile(workspace, file) ?? workspace.projects[0];
+}
+
+export function findProjectForFile(
+  workspace: Pick<AnalysisWorkspace, "projects" | "targetDir">,
+  file: string,
+): AnalysisProject | undefined {
+  const absolute = path.resolve(workspace.targetDir, file);
+  return workspace.projects.find((project) =>
+    within(absolute, project.targetDir),
+  );
+}
+
+export function projectPath(project: AnalysisProject, file: string): string {
+  return normalizePath(path.join(project.prefix, file));
+}
+
+export function projectSource(
+  workspace: Pick<AnalysisWorkspace, "projects" | "targetDir">,
+  file: string,
+): { project: AnalysisProject; file: string } {
+  const project = projectForFile(workspace, file);
+  return {
+    project,
+    file: normalizePath(
+      path.relative(project.targetDir, path.resolve(workspace.targetDir, file)),
+    ),
+  };
+}
+
+function within(file: string, directory: string): boolean {
+  const relative = path.relative(directory, file);
+  return (
+    relative !== ".." &&
+    !relative.startsWith(`..${path.sep}`) &&
+    !path.isAbsolute(relative)
+  );
 }

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,
@@ -212,8 +216,22 @@ export async function mapAppChanges(
     createAnalysisWorkspace(targetDir),
     resolveWorkspaceScope(git.repositoryRoot, canonicalTargetDir),
   ]);
+  for (const project of workspace.projects.slice(1)) {
+    if (isAbsoluteWithin(project.canonicalDir, git.repositoryRoot)) {
+      workspaceScope.dependencyDirectories.add(
+        normalizePath(path.relative(git.repositoryRoot, project.canonicalDir)),
+      );
+    }
+  }
   const governingFiles = new Set(
-    workspace.compilerConfigFiles
+    [
+      ...workspace.compilerConfigFiles,
+      ...workspace.projects.flatMap((project) =>
+        project.config.configFile
+          ? [path.join(project.targetDir, project.config.configFile)]
+          : [],
+      ),
+    ]
       .map((file) =>
         path.resolve(
           canonicalTargetDir,
@@ -281,6 +299,11 @@ export async function mapAppChanges(
     changedFiles,
     git.repositoryRoot,
     canonicalTargetDir,
+    workspace.projects
+      .slice(1)
+      .map((project) =>
+        normalizePath(path.relative(git.repositoryRoot, project.canonicalDir)),
+      ),
   );
   for (const change of appSourceChanges) {
     const directNodes = nodesByFile.get(change.file) ?? [];
@@ -746,6 +769,7 @@ function appRelativeSourceChanges(
   files: AppChangedFile[],
   repositoryRoot: string,
   canonicalTargetDir: string,
+  sourcePackages: string[],
 ): Array<{
   file: string;
   repositoryPath: string;
@@ -760,9 +784,15 @@ function appRelativeSourceChanges(
     status: GitChangedFileStatus;
   }> = [];
   for (const changed of files) {
-    if (changed.scope !== "app") continue;
+    if (changed.scope !== "app" && changed.scope !== "workspace-dependency")
+      continue;
     for (const repositoryPath of changedFilePaths(changed)) {
-      if (!isWithin(repositoryPath, targetPrefix)) continue;
+      if (
+        ![targetPrefix, ...sourcePackages].some((prefix) =>
+          isWithin(repositoryPath, prefix),
+        )
+      )
+        continue;
       const file = targetPrefix
         ? normalizePath(path.posix.relative(targetPrefix, repositoryPath))
         : repositoryPath;
@@ -794,7 +824,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 +856,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 +1034,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 +1321,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 +1365,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);
@@ -1376,8 +1404,8 @@ function appWideChangeReasons(
     const message =
       scope === "workspace-dependency"
         ? scoped.length === 1
-          ? `Direct local dependency ${changedFile} changed.`
-          : `${scoped.length} direct local dependency files changed, including ${changedFile}.`
+          ? `Local source dependency ${changedFile} changed.`
+          : `${scoped.length} local source dependency files changed, including ${changedFile}.`
         : scoped.length === 1
           ? `Governing file ${changedFile} changed.`
           : `${scoped.length} governing files changed, including ${changedFile}.`;