@beignet/cli 0.0.52 → 0.0.53

package/src/app-map.ts

@@ -23,7 +23,10 @@ import {
 import {
   type AnalysisWorkspace,
   createAnalysisWorkspace,
+  projectPath,
+  projectSource,
 } from "./analysis/workspace.js";
+import { workspaceRouteContracts } from "./analysis/workspace-routes.js";
 import type { AppMapNodeKind } from "./app-map-schema.js";
 import { directoryPath } from "./config.js";
 import {
@@ -215,9 +218,8 @@ export async function mapApp(
   const definitions = new Map<string, DefinitionRecord>();
   const definitionBySource = new Map<string, string>();
   const registries: RegistryRecord[] = [];
-  const featuresPath = directoryPath(workspace.config.paths.features);
-  const featureNames = discoverFeatureNames(workspace, featuresPath);
-  const testRoots = appTestRoots(workspace.config.paths);
+  const features = discoverFeatures(workspace);
+  const featureNames = [...features.keys()];
 
   const addNode = (node: AppMapNode) => {
     const existing = nodes.get(node.id);
@@ -235,11 +237,9 @@ export async function mapApp(
   };
   const addEdge = (edge: AppMapEdge) => edges.push(edge);
 
-  for (const feature of featureNames) {
-    const featureFiles = filesForFeature(
-      workspace.files,
-      featuresPath,
-      feature,
+  for (const [feature, featurePath] of features) {
+    const featureFiles = workspace.files.filter((file) =>
+      file.startsWith(`${featurePath}/`),
     );
     const roles = summarizeFeatureFiles(featureFiles);
     addNode({
@@ -247,7 +247,7 @@ export async function mapApp(
       kind: "feature",
       name: feature,
       feature,
-      source: { file: `${featuresPath}/${feature}` },
+      source: { file: featurePath },
       status: "declared",
       details: roles,
     });
@@ -255,10 +255,14 @@ export async function mapApp(
 
   for (const file of workspace.files.filter(
     (candidate) =>
-      isAppTestFile(candidate) && isWithinAppTestRoots(candidate, testRoots),
+      isAppTestFile(candidate) &&
+      isWithinAppTestRoots(
+        projectSource(workspace, candidate).file,
+        appTestRoots(projectSource(workspace, candidate).project.config.paths),
+      ),
   )) {
     const id = `test:${file}`;
-    const feature = featureForFile(file, featuresPath);
+    const feature = featureForFile(file, workspace);
     addNode({
       id,
       kind: "test",
@@ -276,7 +280,7 @@ export async function mapApp(
   const contractIdsByExport = new Map<string, string[]>();
   for (const contract of inspection.contracts) {
     const id = `contract:${contract.file}#${contract.exportName}`;
-    const feature = featureForFile(contract.file, featuresPath);
+    const feature = featureForFile(contract.file, workspace);
     contractIds.set(symbolKey(contract.file, contract.exportName), id);
     const exports = contractIdsByExport.get(contract.exportName) ?? [];
     exports.push(id);
@@ -321,8 +325,8 @@ export async function mapApp(
       id,
       kind: "route",
       name: `${route.method} ${route.path}`,
-      ...(featureForFile(route.file, featuresPath)
-        ? { feature: featureForFile(route.file, featuresPath) }
+      ...(featureForFile(route.file, workspace)
+        ? { feature: featureForFile(route.file, workspace) }
         : {}),
       source: {
         file: route.handlerFile ?? route.file,
@@ -375,7 +379,7 @@ export async function mapApp(
         const runtimeName = literalText(useCaseCall.arguments[0]);
         if (runtimeName) {
           const kind = callMemberName(useCaseCall) as "command" | "query";
-          const feature = featureForFile(file, featuresPath);
+          const feature = featureForFile(file, workspace);
           const id = `use-case:${runtimeName}`;
           const node: AppMapNode = {
             id,
@@ -418,7 +422,7 @@ export async function mapApp(
           : undefined;
         const runtimeName = definitionRuntimeName(call, definitionCall);
         if (kind && runtimeName) {
-          const feature = featureForFile(file, featuresPath);
+          const feature = featureForFile(file, workspace);
           const id = `${kind}:${runtimeName}`;
           const status = definitionStatus(
             kind,
@@ -458,7 +462,7 @@ export async function mapApp(
 
       const policyCall = findCall(initializer, new Set(["definePolicy"]));
       if (policyCall && ts.isObjectLiteralExpression(policyCall.arguments[0])) {
-        const feature = featureForFile(file, featuresPath);
+        const feature = featureForFile(file, workspace);
         const policyId = `policy:${file}#${exportName}`;
         addNode({
           id: policyId,
@@ -676,8 +680,11 @@ export async function mapApp(
     contractIdsByExport,
     routeIds,
     definitionBySource,
-    featuresPath,
     diagnostics: inspection.diagnostics,
+    registeredGroups:
+      workspace.projects.length > 1
+        ? (await workspaceRouteContracts(workspace)).groups
+        : undefined,
   });
 
   await addOpenApiSurface({
@@ -711,7 +718,6 @@ export async function mapApp(
   await addUnresolvedLocalImports({ workspace, unresolved });
   await addFeatureDependencies({
     workspace,
-    featuresPath,
     addEdge,
     featureNames: new Set(featureNames),
   });
@@ -928,12 +934,12 @@ async function addRouteGroups(args: {
   contractIdsByExport: Map<string, string[]>;
   routeIds: Map<string, string>;
   definitionBySource: Map<string, string>;
-  featuresPath: string;
+  registeredGroups?: Set<string>;
   diagnostics: InspectDiagnostic[];
 }): Promise<void> {
   const routeFiles = args.workspace.files.filter(
     (file) =>
-      featureForFile(file, args.featuresPath) !== undefined &&
+      featureForFile(file, args.workspace) !== undefined &&
       isAnalysisSourceFile(file) &&
       stripSourceFileExtension(file).endsWith("/routes"),
   );
@@ -949,17 +955,20 @@ async function addRouteGroups(args: {
       const options = call?.arguments[0];
       if (!call || !options || !ts.isObjectLiteralExpression(options)) continue;
 
-      const feature = featureForFile(file, args.featuresPath);
+      const feature = featureForFile(file, args.workspace);
       const groupName = literalText(
         propertyAssignment(options, "name")?.initializer,
       );
       const id = `route-group:${file}#${exportName}`;
-      const missing = args.diagnostics.some(
-        (diagnostic) =>
-          diagnostic.code === "BEIGNET_ROUTE_GROUP_UNREGISTERED" &&
-          diagnostic.subject?.file === file &&
-          diagnostic.subject.exportName === exportName,
-      );
+      const missing =
+        (args.registeredGroups !== undefined &&
+          !args.registeredGroups.has(`${file}#${exportName}`)) ||
+        args.diagnostics.some(
+          (diagnostic) =>
+            diagnostic.code === "BEIGNET_ROUTE_GROUP_UNREGISTERED" &&
+            diagnostic.subject?.file === file &&
+            diagnostic.subject.exportName === exportName,
+        );
       args.addNode({
         id,
         kind: "route-group",
@@ -1080,8 +1089,10 @@ async function addPorts(args: {
 }): Promise<void> {
   const portsFile = args.workspace.config.paths.ports;
   if (!args.workspace.fileSet.has(portsFile)) return;
-  const sourceFile = await args.workspace.readSourceFile(portsFile);
-  const analysis = await analyzePortWiring(args.workspace);
+  const analysis = await analyzePortWiring(
+    args.workspace,
+    args.workspace.projects.length > 1 ? args.sourceIndex : undefined,
+  );
   if (analysis.declarationIndeterminate) {
     args.unresolved.push({
       code: "app_ports_declaration_unresolved",
@@ -1098,11 +1109,12 @@ async function addPorts(args: {
   }
   for (const name of analysis.declared) {
     const property = analysis.properties.get(name);
+    const propertyFile = analysis.propertyFiles.get(name) ?? portsFile;
     const feature = property
       ? await portFeature(
           property.type,
-          portsFile,
-          args.workspace.config.paths.features,
+          propertyFile,
+          args.workspace,
           args.sourceIndex,
         )
       : undefined;
@@ -1113,7 +1125,7 @@ async function addPorts(args: {
       name,
       ...(feature ? { feature } : {}),
       source: property
-        ? await args.sourceIndex.sourceLocation(portsFile, property)
+        ? await args.sourceIndex.sourceLocation(propertyFile, property)
         : { file: args.workspace.config.paths.portWiring },
       status:
         analysis.bound.has(name) || analysis.deferred.has(name)
@@ -1125,7 +1137,7 @@ async function addPorts(args: {
           : analysis.deferred.has(name)
             ? "deferred"
             : "unresolved",
-        ...(property?.type ? { type: property.type.getText(sourceFile) } : {}),
+        ...(property?.type ? { type: property.type.getText() } : {}),
       },
     });
     if (feature) {
@@ -1447,7 +1459,6 @@ async function addTables(args: {
 
 async function addFeatureDependencies(args: {
   workspace: AnalysisWorkspace;
-  featuresPath: string;
   addEdge(edge: AppMapEdge): void;
   featureNames: Set<string>;
 }): Promise<void> {
@@ -1466,11 +1477,11 @@ async function addFeatureDependencies(args: {
   >();
 
   for (const file of args.workspace.files.filter(isAnalysisSourceFile)) {
-    const from = featureForFile(file, args.featuresPath);
+    const from = featureForFile(file, args.workspace);
     if (!from || !args.featureNames.has(from)) continue;
     for (const reference of await localImportReferences(args.workspace, file)) {
       if (!reference.resolvedFile) continue;
-      const to = featureForFile(reference.resolvedFile, args.featuresPath);
+      const to = featureForFile(reference.resolvedFile, args.workspace);
       if (!to || to === from || !args.featureNames.has(to)) continue;
       const key = `${from}->${to}`;
       const current = dependencies.get(key) ?? {
@@ -1569,16 +1580,16 @@ async function addUnresolvedContractDeclarations(args: {
 }
 
 function appMapContractSourceFiles(workspace: AnalysisWorkspace): string[] {
-  const contractsPath = directoryPath(workspace.config.paths.contracts);
-  const featureOwned =
-    contractsPath === directoryPath(workspace.config.paths.features);
-
   return workspace.files.filter((file) => {
     if (!isAnalysisSourceFile(file) || isAppTestFile(file)) return false;
-    const sourcePath = stripSourceFileExtension(file);
+    const source = projectSource(workspace, file);
+    const contractsPath = directoryPath(source.project.config.paths.contracts);
+    const featureOwned =
+      contractsPath === directoryPath(source.project.config.paths.features);
+    const sourcePath = stripSourceFileExtension(source.file);
     if (featureOwned) {
       const prefix = `${contractsPath}/`;
-      if (!file.startsWith(prefix)) return false;
+      if (!source.file.startsWith(prefix)) return false;
       const parts = sourcePath.slice(prefix.length).split("/");
       return parts.length === 2 && parts[1] === "contracts";
     }
@@ -1599,10 +1610,7 @@ async function registryRecord(args: {
   if (!initializer) return undefined;
   const registry = registryValues(initializer, args.exportName);
   if (!registry) return undefined;
-  const feature = featureForFile(
-    args.file,
-    directoryPath(args.workspace.config.paths.features),
-  );
+  const feature = featureForFile(args.file, args.workspace);
   return {
     file: args.file,
     declaration: args.declaration,
@@ -1814,27 +1822,19 @@ function arrayExpressions(array: ts.ArrayLiteralExpression): ts.Expression[] {
   });
 }
 
-function discoverFeatureNames(
-  workspace: AnalysisWorkspace,
-  featuresPath: string,
-): string[] {
-  const names = new Set<string>();
-  const prefix = `${featuresPath}/`;
+function discoverFeatures(workspace: AnalysisWorkspace): Map<string, string> {
+  const features = new Map<string, string>();
   for (const file of workspace.files) {
-    if (!file.startsWith(prefix)) continue;
-    const feature = file.slice(prefix.length).split("/")[0];
-    if (feature && feature !== "shared") names.add(feature);
+    const feature = featureForFile(file, workspace);
+    if (!feature) continue;
+    const source = projectSource(workspace, file);
+    const root = directoryPath(source.project.config.paths.features);
+    const name = source.file.slice(`${root}/`.length).split("/")[0];
+    features.set(feature, projectPath(source.project, `${root}/${name}`));
   }
-  return [...names].sort();
-}
-
-function filesForFeature(
-  files: string[],
-  featuresPath: string,
-  feature: string,
-): string[] {
-  const prefix = `${featuresPath}/${feature}/`;
-  return files.filter((file) => file.startsWith(prefix));
+  return new Map(
+    [...features].sort(([left], [right]) => left.localeCompare(right)),
+  );
 }
 
 function summarizeFeatureFiles(files: string[]): Record<string, number> {
@@ -1849,18 +1849,20 @@ function summarizeFeatureFiles(files: string[]): Record<string, number> {
 
 function featureForFile(
   file: string,
-  featuresPath: string,
+  workspace: AnalysisWorkspace,
 ): string | undefined {
-  const prefix = `${featuresPath}/`;
-  if (!file.startsWith(prefix)) return undefined;
-  const feature = file.slice(prefix.length).split("/")[0];
-  return feature && feature !== "shared" ? feature : undefined;
+  const source = projectSource(workspace, file);
+  const prefix = `${directoryPath(source.project.config.paths.features)}/`;
+  if (!source.file.startsWith(prefix)) return undefined;
+  const feature = source.file.slice(prefix.length).split("/")[0];
+  if (!feature || feature === "shared") return undefined;
+  return source.project.prefix ? `${source.project.name}:${feature}` : feature;
 }
 
 async function portFeature(
   type: ts.TypeNode | undefined,
   file: string,
-  featuresPath: string,
+  workspace: AnalysisWorkspace,
   sourceIndex: ReturnType<typeof createSourceIndex>,
 ): Promise<string | undefined> {
   if (
@@ -1871,9 +1873,7 @@ async function portFeature(
     return undefined;
   }
   const target = await sourceIndex.resolveName(file, type.typeName.text);
-  return target
-    ? featureForFile(target.file, directoryPath(featuresPath))
-    : undefined;
+  return target ? featureForFile(target.file, workspace) : undefined;
 }
 
 function definitionStatus(

package/src/config.ts

@@ -67,6 +67,12 @@ export type BeignetProviderAuditConfig = {
   ignoreRequiredEnv?: string[];
 };
 
+/** Source packages included in read-only application analysis. */
+export type BeignetWorkspaceConfig = {
+  /** Package directories relative to this app, including transitive dependencies. */
+  packages: string[];
+};
+
 /**
  * User-authored Beignet CLI config.
  */
@@ -75,6 +81,7 @@ export type BeignetConfig = {
   paths?: Partial<BeignetPaths>;
   database?: BeignetDatabaseConfig;
   providerAudit?: BeignetProviderAuditConfig;
+  workspace?: BeignetWorkspaceConfig;
 };
 
 /**
@@ -90,6 +97,7 @@ export type ResolvedBeignetConfig = {
   providerAudit: {
     ignoreRequiredEnv: string[];
   };
+  workspace: BeignetWorkspaceConfig;
   configFile?: string;
 };
 
@@ -134,6 +142,7 @@ export const defaultBeignetConfig: ResolvedBeignetConfig = {
   providerAudit: {
     ignoreRequiredEnv: [],
   },
+  workspace: { packages: [] },
 };
 
 /**
@@ -174,6 +183,7 @@ export function resolveConfig(
     paths: normalizeConfigPaths(paths),
     database: normalizeDatabaseConfig(database),
     providerAudit: normalizeProviderAuditConfig(providerAudit),
+    workspace: normalizeWorkspaceConfig(config.workspace),
     configFile,
   };
 }
@@ -453,6 +463,29 @@ function normalizeIgnoredRequiredEnv(index: number, value: string): string {
   return value.trim();
 }
 
+function normalizeWorkspaceConfig(
+  workspace: BeignetWorkspaceConfig | undefined,
+): BeignetWorkspaceConfig {
+  if (workspace === undefined) return { packages: [] };
+  if (!isRecord(workspace) || !Array.isArray(workspace.packages)) {
+    throw new Error("Beignet config workspace.packages must be an array.");
+  }
+  const packages = workspace.packages.map((value, index) => {
+    if (
+      typeof value !== "string" ||
+      !value.trim() ||
+      path.isAbsolute(value.trim()) ||
+      path.win32.isAbsolute(value.trim())
+    ) {
+      throw new Error(
+        `Beignet config workspace.packages[${index}] must be a relative package directory.`,
+      );
+    }
+    return path.posix.normalize(normalizePath(value.trim())).replace(/\/$/, "");
+  });
+  return { packages: [...new Set(packages)].sort() };
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/src/index.ts

@@ -1853,6 +1853,30 @@ const scheduleRoutes = buildRouteMap({
   },
 });
 
+const encryptionKeyCommand = buildCommand<{ json?: boolean }, [], CliContext>({
+  docs: {
+    brief: "Print a new encryption key without changing environment files.",
+  },
+  parameters: {
+    flags: { json: jsonFlag },
+  },
+  loader: async () => {
+    const { generateEncryptionKey } = await import("@beignet/core/encryption");
+    return async function runEncryptionKey(this: CliContext, flags) {
+      const key = generateEncryptionKey();
+      writeOutput(
+        this,
+        flags.json ? JSON.stringify({ schemaVersion: 1, key }) : key,
+      );
+    };
+  },
+});
+
+const encryptionRoutes = buildRouteMap({
+  docs: { brief: "Manage application encryption." },
+  routes: { key: encryptionKeyCommand },
+});
+
 const completionShellFlagParameters = {
   shell: {
     kind: "enum",
@@ -2449,6 +2473,7 @@ Run npm create beignet@latest (or bun create beignet) to scaffold a new app.`,
     create: createCommand,
     db: dbRoutes,
     doctor: doctorCommand,
+    encryption: encryptionRoutes,
     explain: explainRoutes,
     lint: lintCommand,
     map: mapCommand,