@smoothbricks/cli 0.10.3 → 0.10.4

package/src/nx/index.ts

@@ -2,7 +2,13 @@ import { existsSync } from 'node:fs';
 import { lstat, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { $ } from 'bun';
-import { isRecord, recordProperty } from '../lib/json.js';
+import {
+  type NxDependsOn,
+  type NxProjectJson,
+  type NxTargetConfig,
+  parseNxProjectJsonText,
+  parseStringArrayText,
+} from '../lib/json.js';
 import { decode, run } from '../lib/run.js';
 
 export interface ProjectTargets {
@@ -33,100 +39,116 @@ export function nxCacheDirectories(root: string): string[] {
   return [join(root, '.nx/cache'), join(root, '.nx/workspace-data'), join(root, 'node_modules/.cache/nx')];
 }
 
-export function targetNamesFromNxProjectJson(value: unknown): string[] {
-  const targets = isRecord(value) ? recordProperty(value, 'targets') : null;
+export function targetNamesFromNxProjectJson(value: NxProjectJson | null | undefined): string[] {
+  const targets = value?.targets;
   return targets ? Object.keys(targets).sort((a, b) => a.localeCompare(b)) : [];
 }
 
-export function projectRootFromNxProjectJson(value: unknown): string | undefined {
-  return isRecord(value) && typeof value.root === 'string' ? value.root : undefined;
+export function projectRootFromNxProjectJson(value: NxProjectJson | null | undefined): string | undefined {
+  return typeof value?.root === 'string' ? value.root : undefined;
 }
 
-export function buildDependsOnFromNxProjectJson(value: unknown): string[] | undefined {
+export function buildDependsOnFromNxProjectJson(value: NxProjectJson | null | undefined): string[] | undefined {
   return targetDependenciesFromNxProjectJson(value).get('build');
 }
 
-export function targetDependenciesFromNxProjectJson(value: unknown): Map<string, string[]> {
-  const targets = isRecord(value) ? recordProperty(value, 'targets') : null;
+export function targetDependenciesFromNxProjectJson(value: NxProjectJson | null | undefined): Map<string, string[]> {
+  const targets = value?.targets;
   const dependencies = new Map<string, string[]>();
   if (!targets) {
     return dependencies;
   }
   for (const [targetName, target] of Object.entries(targets)) {
-    if (!isRecord(target) || !Array.isArray(target.dependsOn)) {
+    if (!target.dependsOn) {
       continue;
     }
     const entries: string[] = [];
     for (const dependency of target.dependsOn) {
-      if (typeof dependency === 'string') {
-        entries.push(dependency);
+      const local = localDependsOnTarget(dependency);
+      if (local === undefined) {
+        if (isInvalidDependsOn(dependency)) {
+          throw new Error(`Nx target ${targetName} has an invalid dependsOn entry.`);
+        }
         continue;
       }
-      if (!isRecord(dependency) || typeof dependency.target !== 'string') {
-        throw new Error(`Nx target ${targetName} has an invalid dependsOn entry.`);
-      }
-      if (dependency.projects !== undefined && dependency.projects !== 'self') {
-        throw new Error(`Nx target ${targetName} uses unsupported cross-project dependsOn for ${dependency.target}.`);
-      }
-      entries.push(dependency.target);
+      entries.push(local);
     }
     dependencies.set(targetName, entries);
   }
   return dependencies;
 }
 
-export function targetExecutorsFromNxProjectJson(value: unknown): Map<string, string> {
-  const targets = isRecord(value) ? recordProperty(value, 'targets') : null;
+function localDependsOnTarget(dependency: NxDependsOn): string | undefined {
+  if (typeof dependency === 'string') {
+    return dependency;
+  }
+  if (typeof dependency.target !== 'string') {
+    return undefined;
+  }
+  if (dependency.projects !== undefined && dependency.projects !== 'self') {
+    // Target closures are intentionally project-local. Nx schedules explicit
+    // cross-project prerequisites itself; treating them as local targets
+    // would collect or verify outputs from the wrong project.
+    return undefined;
+  }
+  return dependency.target;
+}
+
+function isInvalidDependsOn(dependency: NxDependsOn): boolean {
+  return typeof dependency !== 'string' && typeof dependency.target !== 'string';
+}
+
+export function targetExecutorsFromNxProjectJson(value: NxProjectJson | null | undefined): Map<string, string> {
+  const targets = value?.targets;
   const executors = new Map<string, string>();
   if (!targets) {
     return executors;
   }
   for (const [targetName, target] of Object.entries(targets)) {
-    if (isRecord(target) && typeof target.executor === 'string') {
+    if (typeof target.executor === 'string') {
       executors.set(targetName, target.executor);
     }
   }
   return executors;
 }
 
-export function targetOutputsFromNxProjectJson(value: unknown): Map<string, string[]> {
+export function targetOutputsFromNxProjectJson(value: NxProjectJson | null | undefined): Map<string, string[]> {
   return targetStringArraysFromNxProjectJson(value, 'outputs');
 }
 
-export function targetScriptsFromNxProjectJson(value: unknown): Map<string, string> {
-  const targets = isRecord(value) ? recordProperty(value, 'targets') : null;
+export function targetScriptsFromNxProjectJson(value: NxProjectJson | null | undefined): Map<string, string> {
+  const targets = value?.targets;
   const scripts = new Map<string, string>();
   if (!targets) {
     return scripts;
   }
   for (const [targetName, target] of Object.entries(targets)) {
-    if (!isRecord(target)) {
-      continue;
-    }
-    const options = recordProperty(target, 'options');
-    if (typeof options?.script === 'string') {
-      scripts.set(targetName, options.script);
+    if (typeof target.options?.script === 'string') {
+      scripts.set(targetName, target.options.script);
     }
   }
   return scripts;
 }
 
-function targetStringArraysFromNxProjectJson(value: unknown, property: string): Map<string, string[]> {
-  const targets = isRecord(value) ? recordProperty(value, 'targets') : null;
+function targetStringArraysFromNxProjectJson(
+  value: NxProjectJson | null | undefined,
+  property: 'outputs' | 'inputs',
+): Map<string, string[]> {
+  const targets = value?.targets;
   const values = new Map<string, string[]>();
   if (!targets) {
     return values;
   }
   for (const [targetName, target] of Object.entries(targets)) {
-    if (!isRecord(target)) {
-      continue;
-    }
     const entries = target[property];
     if (Array.isArray(entries)) {
-      values.set(
-        targetName,
-        entries.filter((entry): entry is string => typeof entry === 'string'),
-      );
+      const strings: string[] = [];
+      for (const entry of entries) {
+        if (typeof entry === 'string') {
+          strings.push(entry);
+        }
+      }
+      values.set(targetName, strings);
     }
   }
   return values;
@@ -154,8 +176,8 @@ export function projectNamesFromNxShowProjectsOutput(output: string): string[] {
 
   if (trimmed.startsWith('[')) {
     try {
-      const parsed: unknown = JSON.parse(trimmed);
-      if (Array.isArray(parsed) && parsed.every((entry) => typeof entry === 'string')) {
+      const parsed = parseStringArrayText(trimmed);
+      if (parsed) {
         return parsed.sort((a, b) => a.localeCompare(b));
       }
     } catch {
@@ -220,7 +242,10 @@ async function readNxProjectNames(root: string): Promise<string[]> {
 async function readProjectTarget(root: string, project: string): Promise<ProjectTargets> {
   const command = nxShowProjectCommand(project);
   const result = await $`${command.command} ${command.args}`.cwd(root).quiet();
-  const parsed: unknown = JSON.parse(decode(result.stdout));
+  const parsed = parseNxProjectJsonText(decode(result.stdout));
+  if (!parsed) {
+    throw new Error(`Unable to inspect Nx project ${project}.`);
+  }
   const targetDependencies = targetDependenciesFromNxProjectJson(parsed);
   return {
     project,
@@ -233,3 +258,5 @@ async function readProjectTarget(root: string, project: string): Promise<Project
     targetScripts: targetScriptsFromNxProjectJson(parsed),
   };
 }
+
+export type { NxProjectJson, NxTargetConfig };

package/src/pr/index.ts

@@ -1,7 +1,8 @@
 import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import typia from 'typia';
 import { formatMarkerHits, scanRefChangedForMarkers } from '../lib/conflict-markers.js';
-import { isRecord, readJson } from '../lib/json.js';
+import { readJson } from '../lib/json.js';
 import { run, runResult } from '../lib/run.js';
 
 /** 0 = clean/done, 2 = action required (conflicts to resolve), 1 = usage/error. */
@@ -50,6 +51,29 @@ interface PrResolveState {
   startedAt: string;
 }
 
+interface GhPrViewJson {
+  number: number;
+  url: string;
+  headRefName: string;
+  baseRefName: string;
+  isCrossRepository?: boolean;
+}
+
+interface PrResolveStateJson {
+  pr: number;
+  url?: string;
+  headBranch: string;
+  baseBranch: string;
+  remote: string;
+  crossRepo?: boolean;
+  originalBranch?: string;
+  originalSha?: string;
+  startedAt?: string;
+}
+
+const parseGhPrViewJson = typia.json.createIsParse<GhPrViewJson>();
+const isPrResolveStateJson = typia.createIs<PrResolveStateJson>();
+
 /**
  * Agent-first conflict resolution for a GitHub PR.
  *
@@ -209,25 +233,16 @@ async function prMeta(shell: PrResolveShell, root: string, prArg: string): Promi
   if (result.exitCode !== 0) {
     throw new Error(`Could not resolve PR '${prArg}' via gh: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
   }
-  const raw: unknown = JSON.parse(result.stdout);
-  if (!isRecord(raw)) {
+  const raw = parseGhPrViewJson(result.stdout);
+  if (!raw) {
     throw new Error(`gh pr view returned unexpected JSON for '${prArg}'.`);
   }
-  const { number, url, headRefName, baseRefName } = raw;
-  if (
-    typeof number !== 'number' ||
-    typeof url !== 'string' ||
-    typeof headRefName !== 'string' ||
-    typeof baseRefName !== 'string'
-  ) {
-    throw new Error(`gh pr view JSON for '${prArg}' is missing expected fields.`);
-  }
-  const match = /github\.com\/([^/]+\/[^/]+)\/pull\//.exec(url);
+  const match = /github\.com\/([^/]+\/[^/]+)\/pull\//.exec(raw.url);
   return {
-    number,
-    url,
-    headBranch: headRefName,
-    baseBranch: baseRefName,
+    number: raw.number,
+    url: raw.url,
+    headBranch: raw.headRefName,
+    baseBranch: raw.baseRefName,
     crossRepo: raw.isCrossRepository === true,
     nameWithOwner: match ? match[1] : '',
   };
@@ -326,28 +341,19 @@ function readState(statePath: string): PrResolveState | null {
   } catch {
     return null;
   }
-  if (!isRecord(raw)) {
-    return null;
-  }
-  const { pr, url, headBranch, baseBranch, remote, crossRepo, originalBranch, originalSha, startedAt } = raw;
-  if (
-    typeof pr !== 'number' ||
-    typeof headBranch !== 'string' ||
-    typeof baseBranch !== 'string' ||
-    typeof remote !== 'string'
-  ) {
+  if (!isPrResolveStateJson(raw)) {
     return null;
   }
   return {
-    pr,
-    url: typeof url === 'string' ? url : '',
-    headBranch,
-    baseBranch,
-    remote,
-    crossRepo: crossRepo === true,
-    originalBranch: typeof originalBranch === 'string' ? originalBranch : '',
-    originalSha: typeof originalSha === 'string' ? originalSha : '',
-    startedAt: typeof startedAt === 'string' ? startedAt : '',
+    pr: raw.pr,
+    url: raw.url ?? '',
+    headBranch: raw.headBranch,
+    baseBranch: raw.baseBranch,
+    remote: raw.remote,
+    crossRepo: raw.crossRepo === true,
+    originalBranch: raw.originalBranch ?? '',
+    originalSha: raw.originalSha ?? '',
+    startedAt: raw.startedAt ?? '',
   };
 }
 

package/src/release/__tests__/candidates.test.ts

@@ -2,7 +2,8 @@ import { describe, expect, it } from 'bun:test';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { $ } from 'bun';
-import { isRecord } from '../../lib/json.js';
+import type { PackageJson } from '../../lib/json.js';
+import { parsePackageJsonText } from '../../lib/json.js';
 import { type AutoReleaseCandidateShell, autoReleaseCandidatePackages } from '../candidates.js';
 import type { ReleasePackageInfo } from '../core.js';
 import { git, tag, withFixtureRepo, writePackage } from './helpers/fixture-repo.js';
@@ -309,9 +310,9 @@ function gitCandidateShell(
   };
 }
 
-function parseJsonObject(text: string): Record<string, unknown> {
-  const parsed = JSON.parse(text);
-  if (!isRecord(parsed)) {
+function parseJsonObject(text: string): PackageJson {
+  const parsed = parsePackageJsonText(text);
+  if (!parsed) {
     throw new Error('expected JSON object');
   }
   return parsed;

package/src/release/__tests__/trust-publisher.test.ts

@@ -179,6 +179,13 @@ describe('trusted publisher setup', () => {
 
   it('recognizes npm trust access-denied output', () => {
     expect(npmTrustListAccessDenied('{"error":{"code":"E403"}}', '')).toBe(true);
+    expect(npmTrustListAccessDenied('', 'npm error code E401')).toBe(true);
+    expect(
+      npmTrustListAccessDenied(
+        '',
+        'npm error 401 Unauthorized - GET https://registry.npmjs.org/-/package/@scope%2fpkg/trust - {"success":false,"error":"You must be logged in to publish packages."}',
+      ),
+    ).toBe(true);
     expect(npmTrustListAccessDenied('', 'npm error code EOTP')).toBe(false);
   });
 

package/src/release/candidates.ts

@@ -1,4 +1,4 @@
-import { isRecord } from '../lib/json.js';
+import type { PackageJson } from '../lib/json.js';
 import type { ReleasePackageInfo } from './core.js';
 import { releaseTag } from './core.js';
 
@@ -6,8 +6,8 @@ export interface AutoReleaseCandidateShell {
   gitRefExists(ref: string): Promise<boolean>;
   latestStableReleaseRef(projectName: string): Promise<string | null>;
   packageChangedFilesSince(ref: string, packagePath: string): Promise<string[]>;
-  packageJsonAtRef(ref: string, packagePath: string): Promise<Record<string, unknown> | null>;
-  currentPackageJson(packagePath: string): Promise<Record<string, unknown> | null>;
+  packageJsonAtRef(ref: string, packagePath: string): Promise<PackageJson | null>;
+  currentPackageJson(packagePath: string): Promise<PackageJson | null>;
   packageBuildInputPatterns(projectName: string, packagePath: string): Promise<string[]>;
   packageHasHistory(packagePath: string): Promise<boolean>;
 }
@@ -104,23 +104,16 @@ async function packageHasReleasableChangesSince<Package extends ReleasePackageIn
   return false;
 }
 
-function releasableManifestChanged(
-  previousManifest: Record<string, unknown>,
-  currentManifest: Record<string, unknown>,
-): boolean {
+function releasableManifestChanged(previousManifest: PackageJson, currentManifest: PackageJson): boolean {
   for (const key of releasableManifestKeys) {
-    if (!stableJsonEqual(previousManifest[key], currentManifest[key])) {
+    if (!stableJsonEqual(Reflect.get(previousManifest, key), Reflect.get(currentManifest, key))) {
       return true;
     }
   }
   return false;
 }
 
-function isReleasablePackagePath(
-  path: string,
-  manifest: Record<string, unknown> | null,
-  buildInputPatterns: string[],
-): boolean {
+function isReleasablePackagePath(path: string, manifest: PackageJson | null, buildInputPatterns: string[]): boolean {
   return (
     isBuildInputPath(path, buildInputPatterns) || isPackageMetadataPath(path) || isManifestFilesPath(path, manifest)
   );
@@ -195,13 +188,13 @@ function isPackageMetadataPath(path: string): boolean {
   return /^(README|LICENSE|CHANGELOG)(\.|$)/.test(path);
 }
 
-function isManifestFilesPath(path: string, manifest: Record<string, unknown> | null): boolean {
+function isManifestFilesPath(path: string, manifest: PackageJson | null): boolean {
   const files = manifest?.files;
   if (!Array.isArray(files)) {
     return false;
   }
   for (const entry of files) {
-    if (typeof entry !== 'string' || entry.length === 0 || entry.startsWith('!')) {
+    if (entry.length === 0 || entry.startsWith('!')) {
       continue;
     }
     if (matchesManifestFilesEntry(path, entry)) {
@@ -227,10 +220,10 @@ function stableJson(value: unknown): unknown {
   if (Array.isArray(value)) {
     return value.map(stableJson);
   }
-  if (isRecord(value)) {
+  if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
     const normalized: Record<string, unknown> = {};
     for (const key of Object.keys(value).sort()) {
-      normalized[key] = stableJson(value[key]);
+      normalized[key] = stableJson(Reflect.get(value, key));
     }
     return normalized;
   }