@yansirplus/cli 0.5.17 → 0.5.18

package/dist/check/algorithmic/distribution-checks.mjs

@@ -1,3 +1,5 @@
+import { workspaceCatalog } from "../../lib/workspace-manifest.mjs";
+
 export const createDistributionChecks = ({
   fs,
   path,
@@ -29,6 +31,8 @@ export const createDistributionChecks = ({
     /\b(?:node-gyp|prebuild(?:ify|-install)?|cmake-js|node-pre-gyp)\b/u;
   const distributionNativeFilePattern = /(?:^|\/)(?:binding\.gyp|CMakeLists\.txt)$|\.node$/u;
   const distributionSourcePattern = /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs|d\.ts)$/u;
+  const sourceEffectPeerSpecifier = () =>
+    workspaceCatalog(repoRoot).effect === undefined ? undefined : "catalog:";
 
   const distributionFinding = ({
     kind,
@@ -620,7 +624,7 @@ export const createDistributionChecks = ({
             distributionUnitFinding({
               kind: "package-unit-effect-peer-invariant",
               unit,
-              message: `effect peer range must match root catalog single source ${expectedEffectRange}`,
+              message: `effect peer range must use catalog single source ${expectedEffectRange}`,
               specifier: "effect",
               target: peer.range,
             }),
@@ -667,7 +671,7 @@ export const createDistributionChecks = ({
         ? distributionRoots.targetProfiles.map((profile) => profile.id)
         : [],
     );
-    const expectedEffectRange = readJson("package.json").catalog?.effect;
+    const expectedEffectRange = sourceEffectPeerSpecifier();
     return [
       ...packageUnitsRegistryFindings({
         registry: packageUnits,
@@ -856,10 +860,7 @@ export const createDistributionChecks = ({
           edges: graph.edges,
         });
       }),
-      ...distributionEffectPeerFindings(
-        recordsWithManifests,
-        readJson("package.json").catalog?.effect,
-      ),
+      ...distributionEffectPeerFindings(recordsWithManifests, sourceEffectPeerSpecifier()),
     ].sort(
       (left, right) =>
         compare(left.severity, right.severity) ||
@@ -890,7 +891,7 @@ export const createDistributionChecks = ({
     });
     const effectPeerFindings = distributionEffectPeerFindings(
       recordsWithManifests,
-      readJson("package.json").catalog?.effect,
+      sourceEffectPeerSpecifier(),
     );
     const failures = [
       ...distributionArchitectureFailures(),

package/dist/check/algorithmic/package-boundary-checks.mjs

@@ -825,7 +825,8 @@ export const createPackageBoundaryChecks = ({
     );
     fs.rmSync(outDir, { recursive: true, force: true });
     const args = [
-      "build",
+      "exec",
+      "esbuild",
       entryPath,
       "--outdir",
       outDir,
@@ -835,7 +836,7 @@ export const createPackageBoundaryChecks = ({
     if (profile.ambient === "cloudflare-worker") args.push("--external", "cloudflare:*");
     if (profile.ambient !== "node") args.push("--external", "node:*");
     try {
-      execFileSync("bun", args, {
+      execFileSync("pnpm", args, {
         cwd: repoRoot,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "pipe"],

package/dist/check/algorithmic/repo-surface-checks.mjs

@@ -59,6 +59,27 @@ export const createRepoSurfaceChecks = ({
 
   const checkPublicApi = () => {
     const failures = [];
+    const runtimeRoot = "packages/runtime/src/index.ts";
+    const runtimeRootSource = read(runtimeRoot);
+    const runtimeRootAst = ts.createSourceFile(
+      path.join(repoRoot, runtimeRoot),
+      runtimeRootSource,
+      ts.ScriptTarget.Latest,
+      true,
+    );
+    for (const statement of runtimeRootAst.statements) {
+      if (
+        ts.isExportDeclaration(statement) &&
+        (statement.exportClause === undefined || ts.isNamespaceExport(statement.exportClause))
+      ) {
+        const { line, character } = runtimeRootAst.getLineAndCharacterOfPosition(
+          statement.getStart(runtimeRootAst),
+        );
+        failures.push(
+          `${runtimeRoot}:${line + 1}:${character + 1}: runtime root barrel must use explicit named exports; export-star syntax is forbidden`,
+        );
+      }
+    }
     for (const target of targetPackages()) {
       if (target.apiSource === undefined) {
         failures.push(
@@ -78,7 +99,7 @@ export const createRepoSurfaceChecks = ({
         failures.push(...validateSourceTsdocRecords(target, records));
         const expected = `${sourceTsdocApiMarkdown(target, records).replace(/\s+$/u, "")}\n`;
         if (fs.readFileSync(manifest, "utf8") !== expected) {
-          failures.push(`${target.apiSource} is stale; run bun run docs:generate`);
+          failures.push(`${target.apiSource} is stale; run pnpm run docs:generate`);
         }
       } else if (mode !== "manual") {
         failures.push(`${target.name}: unsupported apiSourceMode ${mode}`);
@@ -254,6 +275,38 @@ export const createRepoSurfaceChecks = ({
     failIfAny("repo tooling surface", failures);
   };
 
+  const checkEvalResultArtifactBoundary = () => {
+    const failures = [];
+    if (!read(".gitignore").split(/\r?\n/u).includes(".agentos/eval-results/")) {
+      failures.push(".gitignore: missing .agentos/eval-results/ ignore entry");
+    }
+
+    const writerPath = "packages/cli/src/build/build-cli.ts";
+    const writer = read(writerPath);
+    if (!writer.includes('path.join(cwd, ".agentos", "eval-results")')) {
+      failures.push(`${writerPath}: eval runner must own the eval-results output path`);
+    }
+    if (!writer.includes("writeEvalReportArtifact")) {
+      failures.push(`${writerPath}: eval runner must write a derived eval report artifact`);
+    }
+
+    const forbiddenReaders = [
+      "packages/cli/src/build/agent-authoring",
+      "packages/cli/src/generate",
+      "packages/runtime/src",
+      "packages/core/src",
+      "packages/evals/src",
+      "agent-catalog/agentOS",
+    ];
+    for (const file of forbiddenReaders.flatMap((root) => walk(root))) {
+      if (!/\.(?:mjs|js|ts|tsx|md|json)$/u.test(file)) continue;
+      if (read(file).includes("eval-results")) {
+        failures.push(`${file}: eval-results must remain write-only derived output`);
+      }
+    }
+    failIfAny("eval result artifact boundary", failures);
+  };
+
   return {
     manifestEntries,
     manifestNames,
@@ -262,6 +315,7 @@ export const createRepoSurfaceChecks = ({
     ruleConstraints,
     checkPublicApi,
     checkEventNamespaces,
+    checkEvalResultArtifactBoundary,
     checkRepoToolingSurface,
   };
 };

package/dist/check/algorithmic/static-target-checks.mjs

@@ -1,4 +1,4 @@
-export const createStaticTargetChecks = ({ read, failIfAny }) => {
+export const createStaticTargetChecks = ({ read, readJson, failIfAny }) => {
   const sliceBetweenMarkers = (source, startMarker, endMarker) => {
     const start = source.indexOf(startMarker);
     if (start === -1) return "";
@@ -12,6 +12,7 @@ export const createStaticTargetChecks = ({ read, failIfAny }) => {
     const workspaceAgentSourcePath = "packages/core/src/workspace-agent.ts";
     const source = read(sourcePath);
     const workspaceAgentSource = read(workspaceAgentSourcePath);
+    const surface = readJson("docs/surface.json");
     const renderWorkspaceStaticTargetSource = sliceBetweenMarkers(
       source,
       "const renderWorkspaceStaticTarget =",
@@ -260,15 +261,17 @@ export const createStaticTargetChecks = ({ read, failIfAny }) => {
       'import semanticDeclarations from "./manifest.json";',
       'import deploymentProvenance from "./deployment.json";',
       "createAgentDurableObject",
-      "installCloudflareWorkspaceOperationProvider",
+      "resolveRuntimeInstallGraph",
+      "workspaceOperations",
       "OpenAiCompatibleLlmTransportLive",
+      "preflightOpenAiCompatibleProviderMaterial",
       "defineWorkspaceAgentMount",
-      "bindWorkspaceToolsForRuntime",
       "makeCloudflareWorkspaceEnv",
       "getSandbox",
       "generatedCustomTools",
       "llmTransport: () => OpenAiCompatibleLlmTransportLive",
-      "extensions: (env) => workspaceOperationInstallFor(env).extensions",
+      "generatedCapabilityInstallGraphFor",
+      "extensions: (env) => generatedCapabilityInstallGraphFor(env).extensions",
       "override submit(spec: AgentSubmitSpec): Promise<SubmitResult>",
       "submitRunInput(input: SubmitRunInput): Promise<SubmitResult>",
       "readWorkspaceFile(",
@@ -281,16 +284,57 @@ export const createStaticTargetChecks = ({ read, failIfAny }) => {
       }
     }
 
+    const requiredSkillSupportMarkers = [
+      "GENERATED_LOAD_SKILL_TOOL_NAME",
+      "const renderSkillSupport =",
+      "const generatedLoadSkillTool = defineProductTool",
+      "const generatedSkillsSystemAdvert =",
+      "const generatedFrameworkToolsFor =",
+      "const renderSubmitSpecFromRunInput =",
+      "generatedSystemPrompt(input.system, dynamicCapabilityProjection)",
+    ];
+    for (const marker of requiredSkillSupportMarkers) {
+      if (!source.includes(marker)) {
+        failures.push(
+          `${sourcePath}: generated-static-target-linking: generated skills support missing ${marker}`,
+        );
+      }
+    }
+    const assertProfileSkillProjection = ({ targetSource, profile }) => {
+      for (const marker of [
+        "const hasSkills = normalized.skills.length > 0;",
+        '...(hasSkills ? ["defineProductTool"] : [])',
+        'renderNamedImport(hasSkills ? ["Effect", "Schema"] : ["Effect"], modules.effect)',
+        "${renderSkillSupport(normalized.skills)}",
+        "${renderSubmitSpecFromRunInput(hasSkills)}",
+        "...generatedFrameworkTools",
+      ]) {
+        if (!targetSource.includes(marker)) {
+          failures.push(
+            `${sourcePath}: generated-static-target-linking: ${profile} missing generated skills projection marker ${marker}`,
+          );
+        }
+      }
+    };
+    assertProfileSkillProjection({
+      targetSource: renderWorkspaceStaticTargetSource,
+      profile: "workspace@1",
+    });
+    assertProfileSkillProjection({
+      targetSource: renderChatStaticTargetSource,
+      profile: "chat@1",
+    });
+
     const requiredModuleKinds = [
       '"semantic-json"',
       '"target-runtime"',
       '"target-scope-helper"',
       '"target-worker"',
       '"target-config"',
+      '"capability-runtime"',
       '"provider-runtime"',
       '"workspace-host"',
       '"authored-tool"',
-      '"workspace-binding"',
       '"execution-domain-runtime"',
       '"platform-runtime"',
       '"client-core"',
@@ -305,6 +349,40 @@ export const createStaticTargetChecks = ({ read, failIfAny }) => {
       }
     }
 
+    const packagesBySlug = new Map((surface.packages ?? []).map((pkg) => [pkg.slug, pkg]));
+    const generatedImportAudience = new Set(["default-direct", "generated-only"]);
+    const generatedPackageSpecifiers = [
+      ...source.matchAll(/publicPackageSpecifier\(scope,\s*"([^"]+)"\)/gu),
+    ].map((match) => match[1]);
+    if (generatedPackageSpecifiers.length === 0) {
+      failures.push(
+        `${sourcePath}: generated-static-target-linking: generated package specifier map is empty`,
+      );
+    }
+    for (const specifier of generatedPackageSpecifiers) {
+      const [slug, ...subpathParts] = specifier.split("/");
+      const pkg = packagesBySlug.get(slug);
+      const subpath = subpathParts.length === 0 ? "." : `./${subpathParts.join("/")}`;
+      if (pkg === undefined) {
+        failures.push(
+          `${sourcePath}: generated-static-target-linking: ${specifier} has no docs/surface.json package`,
+        );
+        continue;
+      }
+      const entrypoint = (pkg.entrypoints ?? []).find((entry) => entry.subpath === subpath);
+      if (entrypoint === undefined) {
+        failures.push(
+          `${sourcePath}: generated-static-target-linking: ${pkg.name}${subpath === "." ? "" : subpath.slice(1)} is missing docs/surface.json entrypoint metadata`,
+        );
+        continue;
+      }
+      if (!entrypoint.audiences.some((audience) => generatedImportAudience.has(audience))) {
+        failures.push(
+          `${sourcePath}: generated-static-target-linking: generated target must not import ${pkg.name}${subpath === "." ? "" : subpath.slice(1)} with audiences ${entrypoint.audiences.join(", ")}`,
+        );
+      }
+    }
+
     const durableObjectConfigSections = [
       renderWorkspaceStaticTargetSource,
       renderChatStaticTargetSource,

package/dist/check/algorithmic-checks.mjs

@@ -16,6 +16,8 @@ import {
   tsconfigReferenceEdges,
   workspacePackageRecords as graphWorkspacePackageRecords,
 } from "./package-graph.mjs";
+import { workspacePackagePatterns } from "../lib/workspace-manifest.mjs";
+import { walkRepoSourceFiles } from "../lib/repo-source-files.mjs";
 import { collectAgentDocsModel } from "../lib/agent-docs-model.mjs";
 import { createOwnerChecks } from "./algorithmic/owner-checks.mjs";
 import { createArchitectureChecks } from "./algorithmic/architecture-checks.mjs";
@@ -47,21 +49,7 @@ const read = (relativePath) => fs.readFileSync(path.join(repoRoot, relativePath)
 const readJson = (relativePath) => JSON.parse(read(relativePath));
 const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 
-const walk = (relativePath, options = {}) => {
-  const absolutePath = path.join(repoRoot, relativePath);
-  if (!fs.existsSync(absolutePath)) return [];
-  const stat = fs.statSync(absolutePath);
-  if (stat.isFile()) return [relativePath];
-  const ignored = options.ignored ?? new Set(["node_modules", "dist", ".wrangler", ".turbo"]);
-  const files = [];
-  for (const entry of fs.readdirSync(absolutePath, { withFileTypes: true })) {
-    if (entry.isDirectory() && ignored.has(entry.name)) continue;
-    const child = path.join(relativePath, entry.name);
-    if (entry.isDirectory()) files.push(...walk(child, options));
-    if (entry.isFile()) files.push(child.split(path.sep).join("/"));
-  }
-  return files.sort(compare);
-};
+const walk = (relativePath, options = {}) => walkRepoSourceFiles(repoRoot, relativePath, options);
 
 const failIfAny = (label, failures) => {
   if (failures.length === 0) {
@@ -94,6 +82,7 @@ const manifestNames = repoSurfaceChecks.manifestNames;
 const ruleConstraints = repoSurfaceChecks.ruleConstraints;
 const checkPublicApi = repoSurfaceChecks.checkPublicApi;
 const checkEventNamespaces = repoSurfaceChecks.checkEventNamespaces;
+const checkEvalResultArtifactBoundary = repoSurfaceChecks.checkEvalResultArtifactBoundary;
 const checkRepoToolingSurface = repoSurfaceChecks.checkRepoToolingSurface;
 
 const clientBoundaryChecks = createClientBoundaryChecks({
@@ -340,7 +329,7 @@ const checkModuleGraphOracle = packageBoundaryChecks.checkModuleGraphOracle;
 const checkSubpathNoLeak = packageBoundaryChecks.checkSubpathNoLeak;
 const checkProfileVerification = packageBoundaryChecks.checkProfileVerification;
 
-const staticTargetChecks = createStaticTargetChecks({ read, failIfAny });
+const staticTargetChecks = createStaticTargetChecks({ read, readJson, failIfAny });
 const checkGeneratedStaticTargetLinking = staticTargetChecks.checkGeneratedStaticTargetLinking;
 
 const projectionBoundaryChecks = createProjectionBoundaryChecks({
@@ -379,6 +368,7 @@ const convergenceSmokeChecks = createConvergenceSmokeChecks({
   checkGeneratedStaticTargetLinking,
   checkSpikeHygiene,
   moduleBucketRegistry,
+  workspacePackagePatterns: () => workspacePackagePatterns(repoRoot),
   workspacePackageRecords,
   consumerFacingSpecifierFailures,
   packageUnitPublicSpecifiers,
@@ -400,12 +390,14 @@ const checkDocsSiteBuild = convergenceSmokeChecks.checkDocsSiteBuild;
 const checkCliSurface = convergenceSmokeChecks.checkCliSurface;
 const checkConsumerImports = convergenceSmokeChecks.checkConsumerImports;
 const checkDogfoodSmoke = convergenceSmokeChecks.checkDogfoodSmoke;
+const checkBlueprintRecipes = convergenceSmokeChecks.checkBlueprintRecipes;
 
-const checkBoundaryProjection = () => runCommand("vp check", { cwd: repoRoot });
+const checkBoundaryProjection = () => runCommand("vp fmt --check", { cwd: repoRoot });
 
 const checkerById = new Map([
   ["architecture-sources", checkArchitectureSources],
   ["backend-neutrality", checkBackendNeutrality],
+  ["blueprint-recipes", checkBlueprintRecipes],
   ["boundaries", checkBoundaryProjection],
   ["cli-surface", checkCliSurface],
   ["client-boundaries", checkClientBoundaries],
@@ -419,6 +411,7 @@ const checkerById = new Map([
   ["docs-link-integrity", checkDocsLinkIntegrity],
   ["docs-site-build", checkDocsSiteBuild],
   ["event-namespaces", checkEventNamespaces],
+  ["eval-result-artifact-boundary", checkEvalResultArtifactBoundary],
   ["limit-registry", checkLimitRegistry],
   ["generated-static-target-linking", checkGeneratedStaticTargetLinking],
   ["gate-tier-governance", checkGateTierGovernance],

package/dist/check/default-gate.mjs

@@ -32,9 +32,9 @@ const runStage = (label, command, args) =>
 export const runDefaultGate = async () => {
   const startedAt = Date.now();
   const stages = await Promise.all([
-    runStage("structural", "bun", ["run", "check:structural"]),
-    runStage("typecheck", "bun", ["run", "typecheck"]),
-    runStage("test", "bun", ["run", "test"]),
+    runStage("structural", "pnpm", ["run", "check:structural"]),
+    runStage("typecheck", "pnpm", ["run", "typecheck"]),
+    runStage("test", "pnpm", ["run", "test"]),
   ]);
   for (const stage of stages) {
     console.log(`${stage.label} duration: ${stage.durationMs}ms`);

package/dist/check/effect-scan-gate.mjs

@@ -0,0 +1,121 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+
+const parseArgs = (rawArgs, defaultRepoRoot) => {
+  const args = {
+    repo: defaultRepoRoot,
+    evidence: path.join(os.tmpdir(), "agentos-effect-scan"),
+    scanner: "effect-skill-scan",
+  };
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const arg = rawArgs[index];
+    switch (arg) {
+      case "--repo":
+        if (rawArgs[index + 1] === undefined) throw new Error("--repo requires a path");
+        args.repo = rawArgs[index + 1];
+        index += 1;
+        break;
+      case "--evidence":
+        if (rawArgs[index + 1] === undefined) throw new Error("--evidence requires a path");
+        args.evidence = rawArgs[index + 1];
+        index += 1;
+        break;
+      case "--scanner":
+        if (rawArgs[index + 1] === undefined) throw new Error("--scanner requires a command");
+        args.scanner = rawArgs[index + 1];
+        index += 1;
+        break;
+      default:
+        throw new Error(`unexpected argument ${arg}`);
+    }
+  }
+  return {
+    repo: path.resolve(args.repo),
+    evidence: path.resolve(args.evidence),
+    scanner: args.scanner,
+  };
+};
+
+export const validateEffectScanGateJson = (value) => {
+  const failures = [];
+  if (!isRecord(value)) return ["effect scan gate-json must be an object"];
+  if (value.schemaVersion !== 1) failures.push("effect scan gate-json schemaVersion must be 1");
+  if (typeof value.ok !== "boolean") failures.push("effect scan gate-json ok must be boolean");
+  if (!isRecord(value.tiers)) {
+    failures.push("effect scan gate-json tiers object is required");
+    return failures;
+  }
+  if (!Array.isArray(value.tiers.block)) {
+    failures.push("effect scan gate-json tiers.block array is required");
+  }
+  if (!Array.isArray(value.tiers.report)) {
+    failures.push("effect scan gate-json tiers.report array is required");
+  }
+  if (!isRecord(value.tiers.review)) {
+    failures.push("effect scan gate-json tiers.review object is required");
+  }
+  return failures;
+};
+
+const effectScanBlockCount = (value) =>
+  isRecord(value) && isRecord(value.tiers) && Array.isArray(value.tiers.block)
+    ? value.tiers.block.length
+    : 0;
+
+export const effectScanGateFailures = (value, processExitCode) => {
+  const validationFailures = validateEffectScanGateJson(value);
+  if (validationFailures.length > 0) return validationFailures;
+  const failures = [];
+  const blockCount = effectScanBlockCount(value);
+  if (value.ok !== true) {
+    failures.push("effect scan gate-json ok is false");
+  }
+  if (blockCount > 0) {
+    failures.push(`effect scan gate-json contains ${blockCount} scanner-owned block finding(s)`);
+  }
+  if (processExitCode !== 0 && value.ok === true && blockCount === 0) {
+    failures.push(
+      `effect scan process exited ${processExitCode} while gate-json reported no block findings`,
+    );
+  }
+  return failures;
+};
+
+const parseGateJson = (stdout) => {
+  try {
+    return JSON.parse(stdout);
+  } catch (error) {
+    throw new Error(
+      `effect scan did not emit parseable gate-json: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+};
+
+export const runEffectScanGate = (rawArgs, options) => {
+  const args = parseArgs(rawArgs, options.defaultRepoRoot);
+  fs.rmSync(args.evidence, { recursive: true, force: true });
+  fs.mkdirSync(args.evidence, { recursive: true });
+  const result = spawnSync(
+    args.scanner,
+    [args.repo, "--strict", "--output", "gate-json", "--evidence", args.evidence],
+    {
+      cwd: args.repo,
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024,
+    },
+  );
+  if (result.error !== undefined) {
+    throw new Error(`effect scan failed to start: ${result.error.message}`);
+  }
+  const projection = parseGateJson(result.stdout);
+  process.stdout.write(`${JSON.stringify(projection, null, 2)}\n`);
+  if (result.stderr.length > 0) process.stderr.write(result.stderr);
+  const failures = effectScanGateFailures(projection, result.status ?? 1);
+  if (failures.length > 0) {
+    throw new Error(`agentos check effect-scan: ${failures.join("; ")}`);
+  }
+};

package/dist/check/package-graph.mjs

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import ts from "typescript";
+import { workspacePackageRecords as workspaceManifestPackageRecords } from "../lib/workspace-manifest.mjs";
 
 const compare = (left, right) => left.localeCompare(right);
 const readJsonFile = (file) => JSON.parse(fs.readFileSync(file, "utf8"));
@@ -23,38 +24,7 @@ export const walkFiles = (repoRoot, relativePath, options = {}) => {
   return files.sort(compare);
 };
 
-export const workspacePackageRecords = (repoRoot) => {
-  const rootPackage = readJsonFile(path.join(repoRoot, "package.json"));
-  const workspaces = Array.isArray(rootPackage.workspaces)
-    ? rootPackage.workspaces
-    : Array.isArray(rootPackage.workspaces?.packages)
-      ? rootPackage.workspaces.packages
-      : [];
-  const records = [];
-
-  for (const workspace of workspaces) {
-    if (typeof workspace !== "string") continue;
-    if (workspace.endsWith("/*")) {
-      const base = workspace.slice(0, -2);
-      const baseDir = path.join(repoRoot, base);
-      if (!fs.existsSync(baseDir)) continue;
-      for (const entry of fs.readdirSync(baseDir, { withFileTypes: true })) {
-        if (!entry.isDirectory()) continue;
-        const packagePath = `${base}/${entry.name}`;
-        const packageJsonPath = path.join(repoRoot, packagePath, "package.json");
-        if (!fs.existsSync(packageJsonPath)) continue;
-        records.push({ name: readJsonFile(packageJsonPath).name, path: packagePath });
-      }
-      continue;
-    }
-
-    const packageJsonPath = path.join(repoRoot, workspace, "package.json");
-    if (!fs.existsSync(packageJsonPath)) continue;
-    records.push({ name: readJsonFile(packageJsonPath).name, path: workspace });
-  }
-
-  return records.sort((left, right) => left.path.localeCompare(right.path));
-};
+export const workspacePackageRecords = (repoRoot) => workspaceManifestPackageRecords(repoRoot);
 
 const scriptKindForFile = (fileName) => {
   if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;