@smoothbricks/cli 0.10.2 → 0.10.4

package/src/nx/index.ts

@@ -2,14 +2,23 @@ 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 {
   project: string;
+  root?: string;
   targets: string[];
   buildDependsOn?: string[];
+  targetDependencies?: Map<string, string[]>;
   targetExecutors?: Map<string, string>;
+  targetOutputs?: Map<string, string[]>;
   targetScripts?: Map<string, string>;
 }
 
@@ -30,52 +39,121 @@ 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 buildDependsOnFromNxProjectJson(value: unknown): string[] | undefined {
-  const targets = isRecord(value) ? recordProperty(value, 'targets') : null;
-  const build = targets ? recordProperty(targets, 'build') : null;
-  if (!Array.isArray(build?.dependsOn) || !build.dependsOn.every((entry) => typeof entry === 'string')) {
+export function projectRootFromNxProjectJson(value: NxProjectJson | null | undefined): string | undefined {
+  return typeof value?.root === 'string' ? value.root : undefined;
+}
+
+export function buildDependsOnFromNxProjectJson(value: NxProjectJson | null | undefined): string[] | undefined {
+  return targetDependenciesFromNxProjectJson(value).get('build');
+}
+
+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 (!target.dependsOn) {
+      continue;
+    }
+    const entries: string[] = [];
+    for (const dependency of target.dependsOn) {
+      const local = localDependsOnTarget(dependency);
+      if (local === undefined) {
+        if (isInvalidDependsOn(dependency)) {
+          throw new Error(`Nx target ${targetName} has an invalid dependsOn entry.`);
+        }
+        continue;
+      }
+      entries.push(local);
+    }
+    dependencies.set(targetName, entries);
+  }
+  return dependencies;
+}
+
+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 build.dependsOn;
+  return dependency.target;
 }
 
-export function targetExecutorsFromNxProjectJson(value: unknown): Map<string, string> {
-  const targets = isRecord(value) ? recordProperty(value, 'targets') : null;
+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 targetScriptsFromNxProjectJson(value: unknown): Map<string, string> {
-  const targets = isRecord(value) ? recordProperty(value, 'targets') : null;
+export function targetOutputsFromNxProjectJson(value: NxProjectJson | null | undefined): Map<string, string[]> {
+  return targetStringArraysFromNxProjectJson(value, 'outputs');
+}
+
+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: 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)) {
+    const entries = target[property];
+    if (Array.isArray(entries)) {
+      const strings: string[] = [];
+      for (const entry of entries) {
+        if (typeof entry === 'string') {
+          strings.push(entry);
+        }
+      }
+      values.set(targetName, strings);
+    }
+  }
+  return values;
+}
+
 export function formatProjectTargetLines(projects: ProjectTargets[]): string {
   return projects
     .flatMap((project) => project.targets.map((target) => `${project.project}:${target}`))
@@ -98,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 {
@@ -164,12 +242,21 @@ 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,
+    root: projectRootFromNxProjectJson(parsed),
     targets: targetNamesFromNxProjectJson(parsed),
-    buildDependsOn: buildDependsOnFromNxProjectJson(parsed),
+    buildDependsOn: targetDependencies.get('build'),
+    targetDependencies,
     targetExecutors: targetExecutorsFromNxProjectJson(parsed),
+    targetOutputs: targetOutputsFromNxProjectJson(parsed),
     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__/fixture-repo.test.ts

@@ -175,7 +175,9 @@ describe('release planning with fixture git repositories', () => {
       const summaries = await repairPendingTargets(shell, pending, restoreRef, false);
 
       expect(shell.checkouts).toEqual([githubOnlySha, npmAndGithubSha, restoreRef]);
-      expect(shell.devenvLoads).toBe(2);
+      expect(shell.devenvLoads).toBe(3);
+      expect(shell.devenvRefs).toEqual([githubOnlySha, npmAndGithubSha, headSha]);
+      await expect(readFile(join(runner, '.generated-tool-ref'), 'utf8')).resolves.toBe(`${headSha}\n`);
       expect(shell.builds).toEqual([['@scope/b']]);
       expect(shell.publishes).toEqual([{ name: '@scope/b', version: '2.0.0-beta.1', distTag: 'next', dryRun: false }]);
       expect(shell.githubCreates).toEqual([
@@ -189,40 +191,36 @@ describe('release planning with fixture git repositories', () => {
     });
   });
 
-  it('pushes current release refs to a local bare remote and another clone can fetch them', async () => {
+  it('pushes current release refs to a local bare remote', async () => {
     await withFixtureRepo(async (author) => {
       await writeWorkspace(author);
       await writeBuildablePackage(author, '@scope/pushed', 'packages/pushed', '1.0.0');
       await git(author, ['add', '.']);
       await git(author, ['commit', '-m', 'release pushed package']);
+      const releaseSha = await gitOutput(author, ['rev-parse', 'HEAD']);
       await git(author, ['init', '--bare', 'remote.git']);
       await git(author, ['remote', 'add', 'origin', join(author, 'remote.git')]);
       await git(author, ['push', 'origin', 'main']);
-      await git(author, ['clone', '--branch', 'main', join(author, 'remote.git'), 'runner']);
-      const runner = join(author, 'runner');
-      await git(runner, ['config', 'user.name', 'Test User']);
-      await git(runner, ['config', 'user.email', 'test@example.com']);
       const pkg: ReleasePackageInfo = {
         name: '@scope/pushed',
         projectName: 'pushed',
         path: 'packages/pushed',
         version: '1.0.0',
       };
-      const shell = new LocalGitRepairShell(runner);
+      const shell = new LocalGitRepairShell(author);
 
       const summary = await completeReleaseAtHead(shell, [pkg], false, false);
 
       expect(summary.pushed).toBe(true);
       expect(shell.pushes).toEqual([['pushed@1.0.0']]);
-      await git(author, ['clone', '--branch', 'main', join(author, 'remote.git'), 'auditor']);
-      const auditor = join(author, 'auditor');
-      await git(auditor, ['fetch', '--tags', 'origin', 'main']);
-      await expect(gitOutput(auditor, ['rev-parse', 'refs/tags/pushed@1.0.0^{}'])).resolves.toBe(
-        await gitOutput(runner, ['rev-parse', 'HEAD']),
-      );
-      await expect(gitSucceeds(auditor, ['rev-parse', '--verify', 'refs/tags/@scope/pushed@1.0.0'])).resolves.toBe(
-        false,
-      );
+      const remoteTags = await gitOutput(author, [
+        'ls-remote',
+        '--tags',
+        'origin',
+        'refs/tags/pushed@1.0.0^{}',
+        'refs/tags/@scope/pushed@1.0.0^{}',
+      ]);
+      expect(remoteTags).toBe(`${releaseSha}\trefs/tags/pushed@1.0.0^{}`);
     });
   });
 
@@ -295,6 +293,7 @@ class LocalGitRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
   readonly publishes: Array<{ name: string; version: string; distTag: string; dryRun: boolean }> = [];
   readonly githubCreates: Array<{ name: string; version: string; dryRun: boolean }> = [];
   devenvLoads = 0;
+  readonly devenvRefs: string[] = [];
 
   constructor(private readonly root: string) {}
 
@@ -360,6 +359,9 @@ class LocalGitRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
 
   async withDevenvEnv<T>(runWithEnv: () => Promise<T>): Promise<T> {
     this.devenvLoads += 1;
+    const currentRef = await this.gitHead();
+    this.devenvRefs.push(currentRef);
+    await writeFile(join(this.root, '.generated-tool-ref'), `${currentRef}\n`);
     return runWithEnv();
   }
 

package/src/release/__tests__/github-release.test.ts

@@ -4,6 +4,7 @@ import type { ReleasePackageInfo } from '../core.js';
 import {
   createOrUpdateGithubRelease,
   type GithubReleaseWriteShell,
+  githubReleaseLookupExists,
   nxProjectChangelogArgs,
   projectChangelogContents,
 } from '../github-release.js';
@@ -26,6 +27,7 @@ describe('GitHub release helpers', () => {
       gitPush: false,
       stageChanges: false,
       createRelease: false,
+      forceChangelogGeneration: true,
       deleteVersionPlans: false,
       dryRun: false,
       from: 'pkg@1.2.2',
@@ -41,6 +43,7 @@ describe('GitHub release helpers', () => {
       gitPush: false,
       stageChanges: false,
       createRelease: false,
+      forceChangelogGeneration: true,
       deleteVersionPlans: false,
       dryRun: true,
       firstRelease: true,
@@ -66,6 +69,14 @@ describe('GitHub release helpers', () => {
     );
   });
 
+  it('distinguishes missing releases from transient GitHub lookup failures', () => {
+    expect(githubReleaseLookupExists('pkg@1.2.3', 0, '{"tagName":"pkg@1.2.3"}', '')).toBe(true);
+    expect(githubReleaseLookupExists('pkg@1.2.3', 1, '', 'HTTP 404: release not found')).toBe(false);
+    expect(() => githubReleaseLookupExists('pkg@1.2.3', 1, '', 'HTTP 503: Service Unavailable')).toThrow(
+      'Unable to inspect GitHub Release pkg@1.2.3.\nHTTP 503: Service Unavailable',
+    );
+  });
+
   it('creates a missing stable GitHub Release from the generated notes file', async () => {
     const shell = new RecordingGithubReleaseShell(false);
 

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

@@ -2,7 +2,9 @@ import { describe, expect, it } from 'bun:test';
 import { type ReleasePackageInfo, type ReleaseTarget, releaseTag } from '../core.js';
 import {
   bumpStableReleaseToNext,
+  collectRepairPlatformOutputs,
   completeReleaseAtHead,
+  type ReleaseRepairOutputsShell,
   type ReleaseRepairShell,
   type ReleaseVersionShell,
   repairPendingTargets,
@@ -23,14 +25,16 @@ const prerelease: ReleasePackageInfo = {
 };
 
 describe('release orchestration', () => {
-  it('repairs an older target with one checkout, one devenv load, npm-only build, and GitHub create calls', async () => {
+  it('repairs an older target and refreshes devenv after restoring the caller ref', async () => {
     const target = releaseTarget('older-release', [stable, prerelease], [stable], [prerelease]);
     const shell = new RecordingRepairShell();
 
     const summaries = await repairPendingTargets(shell, [target], 'restore-ref', false);
 
     expect(shell.checkouts).toEqual(['older-release', 'restore-ref']);
-    expect(shell.devenvLoads).toBe(1);
+    expect(shell.devenvLoads).toBe(2);
+    expect(shell.devenvRefs).toEqual(['older-release', 'restore-ref']);
+    expect(shell.prepares).toEqual(['older-release']);
     expect(shell.builds).toEqual([['@scope/stable']]);
     expect(shell.publishes).toEqual([{ name: '@scope/stable', distTag: 'latest', dryRun: false }]);
     expect(shell.githubCreates).toEqual([{ name: '@scope/prerelease', dryRun: false }]);
@@ -78,6 +82,29 @@ describe('release orchestration', () => {
     ]);
   });
 
+  it('collects historical platform outputs only for npm-missing repair targets', async () => {
+    const githubOnly = releaseTarget('github-only', [prerelease], [], [prerelease]);
+    const npmMissing = releaseTarget('npm-missing', [stable], [stable], []);
+    const shell = new RecordingRepairOutputsShell();
+
+    await collectRepairPlatformOutputs(shell, [githubOnly, npmMissing], 'restore-ref');
+
+    expect(shell.checkouts).toEqual(['npm-missing', 'restore-ref']);
+    expect(shell.devenvRefs).toEqual(['npm-missing', 'restore-ref']);
+    expect(shell.collected).toEqual(['npm-missing']);
+  });
+
+  it('does nothing when no pending release needs npm platform outputs', async () => {
+    const shell = new RecordingRepairOutputsShell();
+    const githubOnly = releaseTarget('github-only', [prerelease], [], [prerelease]);
+
+    await collectRepairPlatformOutputs(shell, [githubOnly], 'restore-ref');
+
+    expect(shell.checkouts).toEqual([]);
+    expect(shell.devenvRefs).toEqual([]);
+    expect(shell.collected).toEqual([]);
+  });
+
   it('publishes a partial HEAD release by building npm-missing packages and creating missing GitHub Releases', async () => {
     const shell = new RecordingRepairShell({ npmMissing: ['@scope/stable'], githubMissing: ['@scope/prerelease'] });
 
@@ -216,15 +243,21 @@ class RecordingRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
   readonly npmQueries: string[][] = [];
   readonly githubQueries: string[][] = [];
   devenvLoads = 0;
+  readonly devenvRefs: string[] = [];
   currentRef = 'head';
   private readonly npmMissing: Set<string>;
   private readonly githubMissing: Set<string>;
+  readonly prepares: string[] = [];
 
   constructor(options: { npmMissing?: string[]; githubMissing?: string[] } = {}) {
     this.npmMissing = new Set(options.npmMissing ?? []);
     this.githubMissing = new Set(options.githubMissing ?? []);
   }
 
+  async prepareRepairTarget(target: ReleaseTarget<ReleasePackageInfo>): Promise<void> {
+    this.prepares.push(target.sha);
+  }
+
   async gitHead(): Promise<string> {
     return this.currentRef;
   }
@@ -264,10 +297,32 @@ class RecordingRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
 
   async withDevenvEnv<T>(runWithEnv: () => Promise<T>): Promise<T> {
     this.devenvLoads += 1;
+    this.devenvRefs.push(this.currentRef);
     return runWithEnv();
   }
 }
 
+class RecordingRepairOutputsShell implements ReleaseRepairOutputsShell<ReleasePackageInfo> {
+  readonly checkouts: string[] = [];
+  readonly collected: string[] = [];
+  readonly devenvRefs: string[] = [];
+  private currentRef = 'head';
+
+  async checkout(ref: string): Promise<void> {
+    this.currentRef = ref;
+    this.checkouts.push(ref);
+  }
+
+  async withDevenvEnv<T>(runWithEnv: () => Promise<T>): Promise<T> {
+    this.devenvRefs.push(this.currentRef);
+    return runWithEnv();
+  }
+
+  async collectRepairTargetOutputs(target: ReleaseTarget<ReleasePackageInfo>): Promise<void> {
+    this.collected.push(target.sha);
+  }
+}
+
 class RecordingVersionShell implements ReleaseVersionShell<ReleasePackageInfo> {
   readonly ensureCalls: string[][] = [];
   readonly nxRuns: Array<{ packages: string[]; bump: string; dryRun: boolean }> = [];