@smoothbricks/cli 0.10.2 → 0.10.4

package/src/monorepo/packed-manifest.ts

@@ -1,22 +1,18 @@
-import { execSync } from 'node:child_process';
 import { $ } from 'bun';
-import { isRecord, recordProperty } from '../lib/json.js';
+import { type PackageJson, parsePackageJsonText } from '../lib/json.js';
 import { decode } from '../lib/run.js';
 import type { PackageInfo } from '../lib/workspace.js';
 import { getWorkspacePackages, workspaceDependencyFields } from '../lib/workspace.js';
+import { publishPackDependencyVersion } from './lockfile.js';
 
-export async function readPackedPackageJson(
-  root: string,
-  tarball: string,
-  packageName: string,
-): Promise<Record<string, unknown>> {
+export async function readPackedPackageJson(root: string, tarball: string, packageName: string): Promise<PackageJson> {
   const result = await $`tar -xOf ${tarball} package/package.json`.cwd(root).quiet().nothrow();
   if (result.exitCode !== 0) {
     throw new Error(`${packageName}: unable to inspect packed package.json.`);
   }
-  const parsed = JSON.parse(decode(result.stdout));
-  if (!isRecord(parsed)) {
-    throw new Error(`${packageName}: packed package.json is not an object.`);
+  const parsed = parsePackageJsonText(decode(result.stdout));
+  if (!parsed) {
+    throw new Error(`${packageName}: packed package.json is invalid.`);
   }
   return parsed;
 }
@@ -24,21 +20,21 @@ export async function readPackedPackageJson(
 export function validatePackedWorkspaceDependencies(
   root: string,
   sourcePackage: PackageInfo,
-  packedPackage: Record<string, unknown>,
+  packedPackage: PackageJson,
+  options: { mode?: 'install' | 'publish' } = {},
 ): string[] {
+  const mode = options.mode ?? 'publish';
   const workspacePackages = getWorkspacePackages(root);
-  const workspaceVersions = new Map(workspacePackages.map((pkg) => [pkg.name, pkg.version]));
-  const projectNameByPackage = new Map(workspacePackages.map((pkg) => [pkg.name, pkg.projectName]));
   const failures: string[] = [];
   for (const field of workspaceDependencyFields) {
-    const sourceDependencies = recordProperty(sourcePackage.json, field);
-    const packedDependencies = recordProperty(packedPackage, field);
+    const sourceDependencies = sourcePackage.json[field];
+    const packedDependencies = packedPackage[field];
     if (!sourceDependencies && !packedDependencies) {
       continue;
     }
 
     for (const [name, range] of Object.entries(packedDependencies ?? {})) {
-      if (typeof range === 'string' && range.startsWith('workspace:')) {
+      if (range.startsWith('workspace:')) {
         failures.push(`${sourcePackage.path}: packed ${field}.${name} must not contain ${range}`);
       }
     }
@@ -47,54 +43,24 @@ export function validatePackedWorkspaceDependencies(
       continue;
     }
     for (const [name, sourceRange] of Object.entries(sourceDependencies)) {
-      const workspaceVersion = workspaceVersions.get(name);
-      if (!workspaceVersion) {
+      const dep = workspacePackages.find((pkg) => pkg.name === name);
+      if (!dep) {
         continue;
       }
       const packedRange = packedDependencies?.[name];
       if (sourceRange !== 'workspace:*') {
         failures.push(`${sourcePackage.path}: source ${field}.${name} must use workspace:*`);
       }
-      // When the workspace dep is at a prerelease version that was never
-      // published, the lockfile sync rewrites it to the latest stable tag
-      // version.  Accept that version as valid.
-      const projectName = projectNameByPackage.get(name);
+      // install: what day-to-day pack embeds (package.json / lockfile aligned)
+      // publish: what pre-publish sync embeds (unpublished -next → last stable tag)
       const expectedVersion =
-        workspaceVersion.includes('-') && projectName
-          ? (latestStableTagVersion(root, projectName) ?? workspaceVersion)
-          : workspaceVersion;
+        mode === 'publish' ? publishPackDependencyVersion(root, dep.projectName, dep.version) : dep.version;
       if (packedRange !== expectedVersion) {
         failures.push(
-          `${sourcePackage.path}: packed ${field}.${name} must be ${expectedVersion}, got ${formatRange(packedRange)}`,
+          `${sourcePackage.path}: packed ${field}.${name} must be ${expectedVersion}, got ${packedRange ?? '<missing>'}`,
         );
       }
     }
   }
   return failures;
 }
-
-function formatRange(value: unknown): string {
-  return typeof value === 'string' ? value : '<missing>';
-}
-
-function latestStableTagVersion(root: string, projectName: string): string | null {
-  try {
-    const output = execSync(`git tag --list '${projectName}@*' --sort=-v:refname`, {
-      cwd: root,
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    const prefix = `${projectName}@`;
-    for (const line of output.split('\n')) {
-      const tag = line.trim();
-      if (!tag.startsWith(prefix)) continue;
-      const version = tag.slice(prefix.length);
-      if (version && !version.includes('-')) {
-        return version;
-      }
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}

package/src/monorepo/packed-package.ts

@@ -4,7 +4,9 @@ import { dirname, join, relative } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { publint } from 'publint';
 import { formatMessage } from 'publint/utils';
-import { isRecord } from '../lib/json.js';
+import typia from 'typia';
+import type { PackageExports, PackageJson } from '../lib/json.js';
+import { parsePackageJsonText } from '../lib/json.js';
 import { printCommandOutput, runResult } from '../lib/run.js';
 import type { PackageInfo } from '../lib/workspace.js';
 import { listPublicPackages } from '../lib/workspace.js';
@@ -80,7 +82,7 @@ async function validatePackedManifest(
 ): Promise<number> {
   let failures = 0;
   const packedPackage = await readPackedPackageJson(root, packed.path, pkg.name);
-  for (const message of validatePackedWorkspaceDependencies(root, pkg, packedPackage)) {
+  for (const message of validatePackedWorkspaceDependencies(root, pkg, packedPackage, { mode: 'install' })) {
     console.error(message);
     failures++;
   }
@@ -92,11 +94,10 @@ async function validateAttw(root: string, pkg: PackageInfo, packed: { path: stri
   const analysis = await attw.checkPackage(await createAttwPackageFromTarball(attw, root, packed.path), {
     excludeEntrypoints: nonJsExportEntrypoints(pkg.json.exports),
   });
-  if (!isRecord(analysis) || analysis.types === false) {
+  if (!isAttwAnalysis(analysis) || analysis.types === false) {
     return 0;
   }
-  const rawProblems = Array.isArray(analysis.problems) ? analysis.problems : [];
-  const problems = rawProblems.filter(isReportedAttwProblem);
+  const problems = (analysis.problems ?? []).filter(isReportedAttwProblem);
   if (problems.length === 0) {
     return 0;
   }
@@ -112,10 +113,30 @@ interface AttwCore {
   checkPackage: (pkg: unknown, options: { excludeEntrypoints: string[] }) => Promise<unknown>;
 }
 
+interface AttwAnalysis {
+  types?: unknown;
+  problems?: unknown[];
+}
+
+interface AttwProblem {
+  kind: string;
+  resolutionKind?: string;
+  entrypoint?: string;
+}
+
+interface AttwCoreExport {
+  Package?: unknown;
+  checkPackage?: unknown;
+}
+
+const isAttwAnalysis = typia.createIs<AttwAnalysis>();
+const isAttwProblem = typia.createIs<AttwProblem>();
+const isAttwCoreExport = typia.createIs<AttwCoreExport>();
+
 async function loadAttwCore(): Promise<AttwCore> {
   const packageJson = fileURLToPath(import.meta.resolve('@arethetypeswrong/core/package.json'));
-  const core = await import(pathToFileURL(join(dirname(packageJson), 'dist', 'index.js')).href);
-  if (!isRecord(core)) {
+  const core: unknown = await import(pathToFileURL(join(dirname(packageJson), 'dist', 'index.js')).href);
+  if (!isAttwCoreExport(core)) {
     throw new Error('@arethetypeswrong/core does not expose the expected API');
   }
   const PackageConstructor = core.Package;
@@ -146,8 +167,8 @@ async function createAttwPackageFromTarball(attw: AttwCore, root: string, tarbal
 
 function createAttwPackageFromDirectory(attw: AttwCore, packageDir: string): unknown {
   const packageJson = readJsonFile(join(packageDir, 'package.json'));
-  const packageName = typeof packageJson.name === 'string' ? packageJson.name : null;
-  const packageVersion = typeof packageJson.version === 'string' ? packageJson.version : null;
+  const packageName = packageJson.name;
+  const packageVersion = packageJson.version;
   if (!packageName || !packageVersion) {
     throw new Error('packed package.json must contain name and version');
   }
@@ -172,16 +193,16 @@ function collectAttwFiles(root: string, current: string, packageName: string, fi
   }
 }
 
-function readJsonFile(path: string): Record<string, unknown> {
-  const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
-  if (!isRecord(parsed)) {
+function readJsonFile(path: string): PackageJson {
+  const parsed = parsePackageJsonText(readFileSync(path, 'utf8'));
+  if (!parsed) {
     throw new Error(`${path} is not a JSON object`);
   }
   return parsed;
 }
 
-function isReportedAttwProblem(problem: unknown): boolean {
-  if (!isRecord(problem) || typeof problem.kind !== 'string') {
+function isReportedAttwProblem(problem: unknown): problem is AttwProblem {
+  if (!isAttwProblem(problem)) {
     return false;
   }
   const flag = attwProblemFlag(problem.kind);
@@ -222,10 +243,7 @@ function attwProblemFlag(kind: string): string | null {
   }
 }
 
-function formatProblemLocation(problem: unknown): string {
-  if (!isRecord(problem)) {
-    return '';
-  }
+function formatProblemLocation(problem: AttwProblem): string {
   const entrypoint = typeof problem.entrypoint === 'string' ? ` ${problem.entrypoint}` : '';
   const resolution =
     typeof problem.resolutionKind === 'string' ? ` ${formatResolutionKind(problem.resolutionKind)}` : '';
@@ -242,8 +260,8 @@ function formatResolutionKind(kind: string): string {
   return kind;
 }
 
-function nonJsExportEntrypoints(exports: unknown): string[] {
-  if (!isRecord(exports)) {
+function nonJsExportEntrypoints(exports: PackageExports): string[] {
+  if (exports === null || exports === undefined || typeof exports === 'string') {
     return [];
   }
   return Object.entries(exports)
@@ -251,13 +269,16 @@ function nonJsExportEntrypoints(exports: unknown): string[] {
     .map(([key]) => key);
 }
 
-function exportPointsToNonJs(value: unknown): boolean {
+function exportPointsToNonJs(value: PackageExports): boolean {
   if (typeof value === 'string') {
     // attw resolves every entrypoint as a module; assets can never have types.
     // Existence of the target files is still validated by publint.
     return value.endsWith('.wasm') || value.endsWith('.css');
   }
-  return isRecord(value) && Object.values(value).some(exportPointsToNonJs);
+  if (value === null || value === undefined) {
+    return false;
+  }
+  return Object.values(value).some(exportPointsToNonJs);
 }
 
 async function packPackage(root: string, pkg: PackageInfo): Promise<{ path: string; arrayBuffer: ArrayBuffer }> {

package/src/monorepo/packs/index.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'bun:test';
 import type { MonorepoPack } from './index.js';
-import { runValidatePacks } from './index.js';
+import { resolvedTargetsByProject, runValidatePacks } from './index.js';
 
 const ctx = { root: '/workspace', syncRuntime: false };
 
@@ -186,4 +186,21 @@ describe('monorepo validation pack phases', () => {
     expect(result).toEqual({ failures: 1, failedChecks: 1 });
     expect(events).toEqual(['pre-fix', 'build']);
   });
+
+  it('propagates parsed target dependencies through the production adapter', () => {
+    const targetDependencies = new Map([
+      ['build', ['compile-linux']],
+      ['compile-linux', ['package-linux']],
+    ]);
+
+    const resolved = resolvedTargetsByProject([
+      {
+        project: 'native',
+        targets: ['build', 'compile-linux', 'package-linux'],
+        targetDependencies,
+      },
+    ]);
+
+    expect(resolved.get('native')?.targetDependencies).toBe(targetDependencies);
+  });
 });

package/src/monorepo/packs/index.ts

@@ -1,9 +1,9 @@
 import { chmodSync, existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { printCommandOutput, runResult, runStatus } from '../../lib/run.js';
-import { readProjectTargets } from '../../nx/index.js';
+import { type ProjectTargets, readProjectTargets } from '../../nx/index.js';
 import { syncBunLockfileVersions, validateBunLockfileVersions } from '../lockfile.js';
-import { validateManagedFiles } from '../managed-files.js';
+import { warnOnManagedFileDrift } from '../managed-files.js';
 import { fixNxSync, validateNxSync } from '../nx-sync.js';
 import { fixPackageHygiene, validatePackageHygiene } from '../package-hygiene.js';
 import {
@@ -24,7 +24,7 @@ import {
   validatePackedPublicPackagePublint,
   validatePackedPublicPackageTypes,
 } from '../packed-package.js';
-import { syncRootRuntimeVersions } from '../runtime.js';
+import { syncRootRuntimeVersions, validateRootRuntimeVersions } from '../runtime.js';
 import { applyToolConfigDefaults, validateToolConfig } from '../tool-validation.js';
 import { applyWranglerDefaults, validateWrangler } from '../wrangler.js';
 
@@ -79,13 +79,22 @@ const packs: MonorepoPack[] = [
     async fixPreBuild(ctx) {
       applyFixableMonorepoDefaults(ctx.root);
       await applyToolConfigDefaults(ctx.root);
-      syncBunLockfileVersions(ctx.root);
+      // Install/CI alignment only — do not rewrite -next to stable tags here.
+      syncBunLockfileVersions(ctx.root, { mode: 'install' });
       await fixNxSync(ctx.root, ctx.verbose === true);
       applyWorkspaceDependencyDefaults(ctx.root, { resolvedTargetsByProject: await readResolvedTargetsByProject(ctx) });
     },
     async validatePreBuild(ctx) {
+      // Runtime pins validate against the live PATH runtimes (devenv shell),
+      // never a stored template — outside devenv the PATH is not authoritative,
+      // mirroring the init-time syncRuntime gate above.
+      const runtimeFailures = ctx.syncRuntime ? await validateRootRuntimeVersions(ctx.root) : 0;
+      // Managed-file drift is derived state (CLI template x pinned version) with
+      // its own remediation flow; it warns instead of failing so validation only
+      // blocks on actual package issues. See warnOnManagedFileDrift.
+      warnOnManagedFileDrift(ctx.root);
       return (
-        validateManagedFiles(ctx.root) +
+        runtimeFailures +
         validateRootPackagePolicy(ctx.root) +
         validateToolConfig(ctx.root) +
         validateNxProjectNames(ctx.root) +
@@ -400,14 +409,14 @@ function printCapturedOutput(output: CapturedOutput): void {
   }
 }
 
-async function readResolvedTargetsByProject(ctx: MonorepoContext): Promise<Map<string, ResolvedProjectTargets>> {
-  const projects = await readProjectTargets(ctx.root);
+export function resolvedTargetsByProject(projects: ProjectTargets[]): Map<string, ResolvedProjectTargets> {
   return new Map(
     projects.map((project) => [
       project.project,
       {
         targets: new Set(project.targets),
         ...(project.buildDependsOn ? { buildDependsOn: project.buildDependsOn } : {}),
+        ...(project.targetDependencies ? { targetDependencies: project.targetDependencies } : {}),
         ...(project.targetExecutors ? { targetExecutors: project.targetExecutors } : {}),
         ...(project.targetScripts ? { targetScripts: project.targetScripts } : {}),
       },
@@ -415,6 +424,10 @@ async function readResolvedTargetsByProject(ctx: MonorepoContext): Promise<Map<s
   );
 }
 
+async function readResolvedTargetsByProject(ctx: MonorepoContext): Promise<Map<string, ResolvedProjectTargets>> {
+  return resolvedTargetsByProject(await readProjectTargets(ctx.root));
+}
+
 function ensureLocalSmooShim(root: string): void {
   const shim = join(root, 'tooling', 'smoo');
   if (!existsSync(shim)) {