forgeos 0.1.0-alpha.0

package/src/forge/compiler/package-manager/executor.ts

@@ -0,0 +1,117 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, isAbsolute, join } from "node:path";
+import {
+  resolveBunExecutable,
+  type BunExecutableResolutionOptions,
+} from "./bun-executable.ts";
+
+export interface CommandRunOptions {
+  cwd: string;
+  env?: Record<string, string | undefined>;
+}
+
+export interface CommandRunResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+export interface CommandExecutor {
+  run(argv: string[], options: CommandRunOptions): Promise<CommandRunResult>;
+}
+
+export function resolvePackageManagerArgv(
+  argv: string[],
+  bunOptions?: BunExecutableResolutionOptions,
+): string[] {
+  return resolveCommandArgv(argv, bunOptions);
+}
+
+export function resolveCommandArgv(
+  argv: string[],
+  bunOptions?: BunExecutableResolutionOptions,
+): string[] {
+  if (argv[0]?.toLowerCase() === "bun" || argv[0]?.toLowerCase() === "bun.exe") {
+    return [resolveBunExecutable(bunOptions), ...argv.slice(1)];
+  }
+
+  const command = argv[0];
+  if (command && process.platform === "win32") {
+    return [resolveWindowsCommand(command), ...argv.slice(1)];
+  }
+
+  return argv;
+}
+
+function resolveWindowsCommand(command: string): string {
+  if (
+    command.includes("\\") ||
+    command.includes("/") ||
+    isAbsolute(command) ||
+    /\.[a-z0-9]+$/i.test(command)
+  ) {
+    return command;
+  }
+
+  const pathEntries = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+  const extensions = [".exe", ".cmd", ".bat", ""];
+  for (const dir of pathEntries) {
+    for (const extension of extensions) {
+      const candidate = join(dir, `${command}${extension}`);
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  }
+
+  return command;
+}
+
+export class PackageManagerCommandError extends Error {
+  readonly exitCode: number;
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly argv: readonly string[];
+
+  constructor(
+    message: string,
+    argv: readonly string[],
+    result: CommandRunResult,
+  ) {
+    super(message);
+    this.name = "PackageManagerCommandError";
+    this.argv = argv;
+    this.exitCode = result.exitCode;
+    this.stdout = result.stdout;
+    this.stderr = result.stderr;
+  }
+}
+
+export const defaultCommandExecutor: CommandExecutor = {
+  async run(argv, options) {
+    const resolvedArgv = resolvePackageManagerArgv(argv);
+    return new Promise<CommandRunResult>((resolve, reject) => {
+      const child = spawn(resolvedArgv[0]!, resolvedArgv.slice(1), {
+        cwd: options.cwd,
+        env: options.env ?? process.env,
+        windowsHide: true,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+
+      const stdout: Buffer[] = [];
+      const stderr: Buffer[] = [];
+
+      child.stdout.on("data", (chunk: Buffer) => stdout.push(chunk));
+      child.stderr.on("data", (chunk: Buffer) => stderr.push(chunk));
+      child.on("error", reject);
+      child.on("close", (code) => {
+        resolve({
+          exitCode: code ?? 1,
+          stdout: Buffer.concat(stdout).toString("utf8"),
+          stderr: Buffer.concat(stderr).toString("utf8"),
+        });
+      });
+    });
+  },
+};

package/src/forge/compiler/package-manager/index.ts

@@ -0,0 +1,22 @@
+export type {
+  PackageManagerAdapter,
+  DryRunAddResult,
+  CreatePackageManagerAdapterOptions,
+} from "./adapter.ts";
+export {
+  createPackageManagerAdapter,
+  detectAndCreatePackageManagerAdapter,
+  dryRunRecipeFallbackMessage,
+  detectPackageManager,
+  detectPackageManagerFromLockfiles,
+  getLockfileForPm,
+  getLockfileCandidates,
+  parsePackageManagerField,
+  LOCKFILE_PM_MAP,
+  buildAddCommand,
+  parsePackageName,
+  readInstalledVersion,
+  defaultCommandExecutor,
+  PackageManagerCommandError,
+} from "./adapter.ts";
+export type { CommandExecutor, CommandRunResult } from "./executor.ts";

package/src/forge/compiler/package-manager/parse-spec.ts

@@ -0,0 +1,16 @@
+/**
+ * Parse a package name from an install spec (e.g. "lodash@4.17.21", "@scope/pkg@1.0.0").
+ */
+export function parsePackageName(spec: string): string {
+  const trimmed = spec.trim();
+  if (trimmed.startsWith("@")) {
+    const slashIdx = trimmed.indexOf("/");
+    if (slashIdx === -1) {
+      return trimmed;
+    }
+    const versionAt = trimmed.indexOf("@", slashIdx + 1);
+    return versionAt === -1 ? trimmed : trimmed.slice(0, versionAt);
+  }
+  const atIdx = trimmed.indexOf("@");
+  return atIdx === -1 ? trimmed : trimmed.slice(0, atIdx);
+}

package/src/forge/compiler/package-manager/version.ts

@@ -0,0 +1,27 @@
+import { join } from "node:path";
+import { nodeFileSystem } from "../fs/index.ts";
+import { parsePackageName } from "./parse-spec.ts";
+
+export function readInstalledVersion(
+  specOrName: string,
+  cwd: string,
+): string | null {
+  const name = parsePackageName(specOrName);
+  const segments = name.startsWith("@")
+    ? name.split("/")
+    : [name];
+  const pkgJsonPath = join(cwd, "node_modules", ...segments, "package.json");
+
+  if (!nodeFileSystem.exists(pkgJsonPath)) {
+    return null;
+  }
+
+  try {
+    const pkg = JSON.parse((nodeFileSystem.readText(pkgJsonPath) ?? "")) as {
+      version?: string;
+    };
+    return typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}

package/src/forge/compiler/package-upgrades/apply.ts

@@ -0,0 +1,195 @@
+import { basename, join, resolve } from "node:path";
+import { nodeFileSystem } from "../fs/index.ts";
+import { createDiagnostic } from "../diagnostics/create.ts";
+import {
+  FORGE_DEPS_APPLY_FAILED,
+  FORGE_DEPS_ROLLBACK_FAILED,
+} from "../diagnostics/codes.ts";
+import { run } from "../orchestrator/run.ts";
+import {
+  createPackageManagerAdapter,
+  detectPackageManager,
+} from "../package-manager/adapter.ts";
+import type { Diagnostic } from "../types/diagnostic.ts";
+import type { PackageUpgradePlan } from "./types.ts";
+
+export interface UpgradeApplyOptions {
+  workspaceRoot: string;
+  planPath: string;
+  yes: boolean;
+  allowScripts: boolean;
+  skipTests: boolean;
+  dryRun: boolean;
+  forceFailure?: boolean;
+}
+
+export interface UpgradeApplyResult {
+  ok: boolean;
+  plan: PackageUpgradePlan | null;
+  diagnostics: Diagnostic[];
+  applied: boolean;
+  rolledBack: boolean;
+  exitCode: 0 | 1;
+}
+
+function assertInside(root: string, target: string): string {
+  const resolvedRoot = resolve(root);
+  const resolvedTarget = resolve(root, target);
+  if (resolvedTarget !== resolvedRoot && !resolvedTarget.startsWith(`${resolvedRoot}\\`) && !resolvedTarget.startsWith(`${resolvedRoot}/`)) {
+    throw new Error(`snapshot target escapes workspace: ${target}`);
+  }
+  return resolvedTarget;
+}
+
+function readPlan(path: string): PackageUpgradePlan {
+  return JSON.parse((nodeFileSystem.readText(path) ?? "")) as PackageUpgradePlan;
+}
+
+function snapshotFiles(workspaceRoot: string, plan: PackageUpgradePlan): string {
+  const snapshotDir = assertInside(workspaceRoot, plan.rollback.snapshotDir);
+  nodeFileSystem.remove(snapshotDir);
+  nodeFileSystem.mkdirp(snapshotDir);
+
+  for (const file of plan.rollback.files) {
+    const source = assertInside(workspaceRoot, file);
+    if (!nodeFileSystem.exists(source)) {
+      continue;
+    }
+    const target = join(snapshotDir, basename(file));
+    nodeFileSystem.copy(source, target);
+  }
+
+  return snapshotDir;
+}
+
+function restoreSnapshot(workspaceRoot: string, plan: PackageUpgradePlan): void {
+  const snapshotDir = assertInside(workspaceRoot, plan.rollback.snapshotDir);
+  for (const file of plan.rollback.files) {
+    const snapshot = join(snapshotDir, basename(file));
+    if (!nodeFileSystem.exists(snapshot)) {
+      continue;
+    }
+    const target = assertInside(workspaceRoot, file);
+    nodeFileSystem.remove(target);
+    nodeFileSystem.copy(snapshot, target);
+  }
+}
+
+export async function applyUpgradePlan(
+  options: UpgradeApplyOptions,
+): Promise<UpgradeApplyResult> {
+  const diagnostics: Diagnostic[] = [];
+  let plan: PackageUpgradePlan | null = null;
+  let applied = false;
+  let rolledBack = false;
+
+  try {
+    plan = readPlan(options.planPath);
+    snapshotFiles(options.workspaceRoot, plan);
+
+    if (options.dryRun) {
+      return { ok: true, plan, diagnostics, applied: false, rolledBack: false, exitCode: 0 };
+    }
+
+    if (options.forceFailure) {
+      throw new Error("forced upgrade failure");
+    }
+
+    const pm = detectPackageManager(options.workspaceRoot);
+    const adapter = createPackageManagerAdapter(pm);
+    await adapter.add(plan.to.spec, {
+      cwd: options.workspaceRoot,
+      ignoreScripts: !options.allowScripts,
+    });
+
+    const generated = await run({
+      workspaceRoot: options.workspaceRoot,
+      check: false,
+      dryRun: false,
+      json: false,
+      concurrency: 4,
+    });
+    diagnostics.push(...generated.errors, ...generated.warnings);
+
+    if (generated.exitCode !== 0) {
+      throw new Error("upgrade validation failed after install");
+    }
+
+    applied = true;
+    return {
+      ok: true,
+      plan,
+      diagnostics,
+      applied,
+      rolledBack,
+      exitCode: 0,
+    };
+  } catch (error) {
+    diagnostics.push(
+      createDiagnostic({
+        severity: "error",
+        code: FORGE_DEPS_APPLY_FAILED,
+        message: error instanceof Error ? error.message : "package upgrade apply failed",
+      }),
+    );
+
+    if (plan) {
+      try {
+        restoreSnapshot(options.workspaceRoot, plan);
+        rolledBack = true;
+      } catch (rollbackError) {
+        diagnostics.push(
+          createDiagnostic({
+            severity: "error",
+            code: FORGE_DEPS_ROLLBACK_FAILED,
+            message: rollbackError instanceof Error ? rollbackError.message : "rollback failed",
+          }),
+        );
+      }
+    }
+
+    return {
+      ok: false,
+      plan,
+      diagnostics,
+      applied,
+      rolledBack,
+      exitCode: 1,
+    };
+  }
+}
+
+export function rollbackUpgradePlan(options: {
+  workspaceRoot: string;
+  planPath: string;
+}): UpgradeApplyResult {
+  const diagnostics: Diagnostic[] = [];
+  try {
+    const plan = readPlan(options.planPath);
+    restoreSnapshot(options.workspaceRoot, plan);
+    return {
+      ok: true,
+      plan,
+      diagnostics,
+      applied: false,
+      rolledBack: true,
+      exitCode: 0,
+    };
+  } catch (error) {
+    diagnostics.push(
+      createDiagnostic({
+        severity: "error",
+        code: FORGE_DEPS_ROLLBACK_FAILED,
+        message: error instanceof Error ? error.message : "rollback failed",
+      }),
+    );
+    return {
+      ok: false,
+      plan: null,
+      diagnostics,
+      applied: false,
+      rolledBack: false,
+      exitCode: 1,
+    };
+  }
+}

package/src/forge/compiler/package-upgrades/comparator.ts

@@ -0,0 +1,181 @@
+import type { ClassifiedPackage } from "../classifier/runtime-matrix.ts";
+import { detectCapabilities } from "../classifier/capabilities.ts";
+import { detectSecrets } from "../classifier/secrets.ts";
+import { resolveByPackageName } from "../recipes/registry.ts";
+import type { PackageApi } from "../types/package-graph.ts";
+import type { RuntimeContext } from "../types/runtime.ts";
+import type {
+  ExportChange,
+  PackageApiDiff,
+  RuntimeDiff,
+  SignatureChange,
+} from "./types.ts";
+
+function exportKey(entrypoint: string, exportName: string): string {
+  return `${entrypoint}\0${exportName}`;
+}
+
+function flattenExports(api: PackageApi): Map<string, ExportChange & { signature: string }> {
+  const flattened = new Map<string, ExportChange & { signature: string }>();
+  for (const entrypoint of api.entrypoints) {
+    for (const exported of entrypoint.exports) {
+      const signature = [exported.signature, ...(exported.declarations ?? [])]
+        .filter(Boolean)
+        .join("\n");
+      flattened.set(exportKey(entrypoint.subpath, exported.name), {
+        entrypoint: entrypoint.subpath,
+        exportName: exported.name,
+        kind: exported.kind,
+        signature,
+      });
+    }
+  }
+  return flattened;
+}
+
+export function comparePackageApi(current: PackageApi, target: PackageApi): PackageApiDiff {
+  const before = flattenExports(current);
+  const after = flattenExports(target);
+  const removedExports: ExportChange[] = [];
+  const addedExports: ExportChange[] = [];
+  const changedSignatures: SignatureChange[] = [];
+
+  for (const [key, exported] of before) {
+    const next = after.get(key);
+    if (!next) {
+      removedExports.push({
+        entrypoint: exported.entrypoint,
+        exportName: exported.exportName,
+        kind: exported.kind,
+      });
+      continue;
+    }
+
+    if (next.signature !== exported.signature) {
+      changedSignatures.push({
+        entrypoint: exported.entrypoint,
+        exportName: exported.exportName,
+        before: exported.signature,
+        after: next.signature,
+        affectedCallsites: [],
+      });
+    }
+  }
+
+  for (const [key, exported] of after) {
+    if (!before.has(key)) {
+      addedExports.push({
+        entrypoint: exported.entrypoint,
+        exportName: exported.exportName,
+        kind: exported.kind,
+      });
+    }
+  }
+
+  const beforeEntrypoints = new Set(current.entrypoints.map((entrypoint) => entrypoint.subpath));
+  const afterEntrypoints = new Set(target.entrypoints.map((entrypoint) => entrypoint.subpath));
+  const changedEntrypoints = [
+    ...[...beforeEntrypoints]
+      .filter((entrypoint) => !afterEntrypoints.has(entrypoint))
+      .map((entrypoint) => ({ entrypoint, kind: "removed" as const })),
+    ...[...afterEntrypoints]
+      .filter((entrypoint) => !beforeEntrypoints.has(entrypoint))
+      .map((entrypoint) => ({ entrypoint, kind: "added" as const })),
+  ].sort((a, b) => `${a.kind}:${a.entrypoint}`.localeCompare(`${b.kind}:${b.entrypoint}`));
+
+  return {
+    removedExports: removedExports.sort((a, b) =>
+      `${a.entrypoint}:${a.exportName}`.localeCompare(`${b.entrypoint}:${b.exportName}`),
+    ),
+    addedExports: addedExports.sort((a, b) =>
+      `${a.entrypoint}:${a.exportName}`.localeCompare(`${b.entrypoint}:${b.exportName}`),
+    ),
+    changedSignatures: changedSignatures.sort((a, b) =>
+      `${a.entrypoint}:${a.exportName}`.localeCompare(`${b.entrypoint}:${b.exportName}`),
+    ),
+    changedEntrypoints,
+    changedJSDoc: [],
+    typeResolutionChanges: [],
+  };
+}
+
+function compatibleSet(classified: ClassifiedPackage | undefined): RuntimeContext[] {
+  return [...(classified?.classification.compatible ?? [])].sort();
+}
+
+function secretNames(classified: ClassifiedPackage | undefined): string[] {
+  if (!classified) {
+    return [];
+  }
+  const recipe = classified.recipe ?? resolveByPackageName(classified.api.name);
+  return detectSecrets(classified.api, recipe ?? undefined)
+    .map((secret) => `${secret.envVar}:${secret.required ? "required" : "optional"}`)
+    .sort();
+}
+
+function capabilityNames(classified: ClassifiedPackage | undefined): string[] {
+  if (!classified) {
+    return [];
+  }
+  const recipe = classified.recipe ?? resolveByPackageName(classified.api.name);
+  const capabilities = detectCapabilities(classified.api, recipe ?? undefined);
+  return Object.entries(capabilities)
+    .filter(([, value]) => {
+      return (
+        typeof value === "object" &&
+        "status" in value &&
+        (value.status === "required" || value.status === "forbidden")
+      );
+    })
+    .map(([name, value]) => `${name}:${"status" in value ? value.status : "unknown"}`)
+    .sort();
+}
+
+function difference<T>(a: T[], b: T[]): T[] {
+  const other = new Set(b);
+  return a.filter((item) => !other.has(item)).sort();
+}
+
+export function compareRuntime(
+  current: ClassifiedPackage | undefined,
+  target: ClassifiedPackage | undefined,
+): RuntimeDiff {
+  const currentContexts = compatibleSet(current);
+  const targetContexts = compatibleSet(target);
+  const currentSecrets = secretNames(current);
+  const targetSecrets = secretNames(target);
+  const currentCapabilities = capabilityNames(current);
+  const targetCapabilities = capabilityNames(target);
+  const recipeChanged = (current?.recipe?.recipeVersion ?? undefined) !==
+    (target?.recipe?.recipeVersion ?? current?.recipe?.recipeVersion ?? undefined);
+
+  return {
+    capabilitiesChanged:
+      difference(targetCapabilities, currentCapabilities).length > 0 ||
+      difference(currentCapabilities, targetCapabilities).length > 0,
+    addedCapabilities: difference(targetCapabilities, currentCapabilities).map((name) => ({
+      name: name.split(":")[0] ?? name,
+      after: name.split(":")[1],
+    })),
+    removedCapabilities: difference(currentCapabilities, targetCapabilities).map((name) => ({
+      name: name.split(":")[0] ?? name,
+      before: name.split(":")[1],
+    })),
+    contextCompatibilityChanged:
+      difference(currentContexts, targetContexts).length > 0 ||
+      difference(targetContexts, currentContexts).length > 0,
+    contextsNowDenied: difference(currentContexts, targetContexts),
+    contextsNowAllowed: difference(targetContexts, currentContexts),
+    secretChanges: {
+      added: difference(targetSecrets, currentSecrets).map((secret) => secret.split(":")[0] ?? secret),
+      removed: difference(currentSecrets, targetSecrets).map((secret) => secret.split(":")[0] ?? secret),
+      changedRequired: targetSecrets
+        .filter((secret) => currentSecrets.includes(`${secret.split(":")[0]}:optional`) && secret.endsWith(":required"))
+        .map((secret) => secret.split(":")[0] ?? secret)
+        .sort(),
+    },
+    recipeChanged,
+    ...(current?.recipe?.recipeVersion ? { previousRecipeVersion: current.recipe.recipeVersion } : {}),
+    ...(target?.recipe?.recipeVersion ? { nextRecipeVersion: target.recipe.recipeVersion } : {}),
+  };
+}

package/src/forge/compiler/package-upgrades/impact.ts

@@ -0,0 +1,139 @@
+import { resolveByPackageName } from "../recipes/registry.ts";
+import type { AppGraph, ForgeSymbol } from "../types/app-graph.ts";
+import type { RuntimeGraph } from "../types/runtime-graph.ts";
+import type { QueryRegistry } from "../types/query-registry.ts";
+import type { LiveQueryRegistry } from "../types/live-query-registry.ts";
+import type { WorkflowRegistry } from "../types/workflow-registry.ts";
+import type { PackageApiDiff, UpgradeImpact } from "./types.ts";
+
+function uniqueSorted(items: string[]): string[] {
+  return [...new Set(items.filter(Boolean))].sort();
+}
+
+function symbolsByFile(appGraph: AppGraph): Map<string, ForgeSymbol[]> {
+  const byFile = new Map<string, ForgeSymbol[]>();
+  for (const symbol of appGraph.symbols) {
+    const list = byFile.get(symbol.file) ?? [];
+    list.push(symbol);
+    byFile.set(symbol.file, list);
+  }
+  return byFile;
+}
+
+function attachAffectedCallsites(apiDiff: PackageApiDiff, appGraph: AppGraph, files: string[]): void {
+  const symbols = symbolsByFile(appGraph);
+  const callsites = files.flatMap((file) =>
+    (symbols.get(file) ?? []).map((symbol) => ({
+      file,
+      symbolName: symbol.name,
+      symbolKind: symbol.kind,
+    })),
+  );
+
+  for (const change of apiDiff.changedSignatures) {
+    change.affectedCallsites = callsites;
+  }
+}
+
+export function analyzeUpgradeImpact(input: {
+  packageName: string;
+  appGraph: AppGraph;
+  runtimeGraph: RuntimeGraph;
+  queryRegistry: QueryRegistry;
+  liveQueryRegistry: LiveQueryRegistry;
+  workflowRegistry: WorkflowRegistry;
+  apiDiff: PackageApiDiff;
+}): UpgradeImpact {
+  const imports = input.appGraph.moduleGraph.nodes
+    .flatMap((node) =>
+      node.directPackageImports
+        .filter((pkgImport) => pkgImport.packageName === input.packageName)
+        .map((pkgImport) => ({
+          file: node.file,
+          specifier: pkgImport.specifier,
+          importKind: pkgImport.importKind,
+        })),
+    )
+    .sort((a, b) => `${a.file}:${a.specifier}`.localeCompare(`${b.file}:${b.specifier}`));
+
+  const files = uniqueSorted(imports.map((imp) => imp.file));
+  const symbols = symbolsByFile(input.appGraph);
+  const commandNames = new Set(
+    input.runtimeGraph.entries
+      .filter((entry) => entry.kind === "command" && files.includes(entry.file))
+      .map((entry) => entry.name),
+  );
+  const actionNames = new Set(
+    input.runtimeGraph.entries
+      .filter((entry) => entry.kind === "action" && files.includes(entry.file))
+      .map((entry) => entry.name),
+  );
+
+  for (const file of files) {
+    for (const symbol of symbols.get(file) ?? []) {
+      if (symbol.kind === "command") {
+        commandNames.add(symbol.name);
+      }
+      if (symbol.kind === "action") {
+        actionNames.add(symbol.name);
+      }
+    }
+  }
+
+  const queries = uniqueSorted(
+    input.queryRegistry.queries
+      .filter((query) => files.includes(query.file))
+      .map((query) => query.name),
+  );
+  const liveQueries = uniqueSorted(
+    input.liveQueryRegistry.liveQueries
+      .filter((query) => files.includes(query.file))
+      .map((query) => query.name),
+  );
+  const workflows = uniqueSorted(
+    input.workflowRegistry.workflows
+      .filter((workflow) => files.includes(workflow.file))
+      .map((workflow) => workflow.name),
+  );
+  const workflowSteps = uniqueSorted(
+    input.workflowRegistry.workflows
+      .filter((workflow) => files.includes(workflow.file))
+      .flatMap((workflow) => workflow.steps.map((step) => `${workflow.name}.${step.name}`)),
+  );
+  const frontendComponents = uniqueSorted(
+    input.appGraph.symbols
+      .filter((symbol) => files.includes(symbol.file) && symbol.kind === "endpoint")
+      .map((symbol) => symbol.name),
+  );
+  const generatedAdapters = uniqueSorted(
+    (resolveByPackageName(input.packageName)?.adapters ?? []).map(
+      (adapter) => `src/forge/_generated/packages/${adapter}`,
+    ),
+  );
+  const tests = uniqueSorted(
+    files
+      .map((file) => file.replace(/^src\//, "tests/").replace(/\.(tsx?|jsx?)$/, ".test.ts"))
+      .filter((file) => file.startsWith("tests/")),
+  );
+
+  attachAffectedCallsites(input.apiDiff, input.appGraph, files);
+
+  return {
+    files,
+    imports,
+    commands: [...commandNames].sort(),
+    queries,
+    liveQueries,
+    actions: [...actionNames].sort(),
+    workflows,
+    workflowSteps,
+    endpoints: uniqueSorted(
+      input.appGraph.symbols
+        .filter((symbol) => files.includes(symbol.file) && symbol.kind === "endpoint")
+        .map((symbol) => symbol.name),
+    ),
+    frontendComponents,
+    generatedAdapters,
+    tests,
+  };
+}