@smoothbricks/cli 0.4.2 → 0.5.0

package/src/monorepo/packed-package.ts

@@ -1,5 +1,7 @@
-import { readFileSync, rmSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
+import { mkdtempSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+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';
@@ -86,39 +88,158 @@ async function validatePackedManifest(
 }
 
 async function validateAttw(root: string, pkg: PackageInfo, packed: { path: string }): Promise<number> {
-  const attwArgs = [
-    packed.path,
-    '--format',
-    'ascii',
-    '--no-color',
-    '--profile',
-    'node16',
-    '--ignore-rules',
-    'cjs-resolves-to-esm',
-    ...attwExcludedEntrypointArgs(pkg),
-  ];
-  const attw = await runResult('attw', attwArgs, root);
-  if (attw.exitCode === 0) {
+  const attw = await loadAttwCore();
+  const analysis = await attw.checkPackage(await createAttwPackageFromTarball(attw, root, packed.path), {
+    excludeEntrypoints: wasmExportEntrypoints(pkg.json.exports),
+  });
+  if (!isRecord(analysis) || analysis.types === false) {
     return 0;
   }
-  printAttwOutput(attw.stdout);
-  printAttwOutput(attw.stderr);
+  const rawProblems = Array.isArray(analysis.problems) ? analysis.problems : [];
+  const problems = rawProblems.filter(isReportedAttwProblem);
+  if (problems.length === 0) {
+    return 0;
+  }
+  for (const problem of problems) {
+    console.error(`${pkg.path}: are-the-types-wrong ${problem.kind}${formatProblemLocation(problem)}`);
+  }
   console.error(`${pkg.path}: are-the-types-wrong validation failed`);
   return 1;
 }
 
-function printAttwOutput(output: string): void {
-  for (const line of output.split('\n')) {
-    if (!line || line.includes('(ignored)')) {
+interface AttwCore {
+  createPackage: (files: Record<string, Uint8Array>, packageName: string, packageVersion: string) => unknown;
+  checkPackage: (pkg: unknown, options: { excludeEntrypoints: string[] }) => Promise<unknown>;
+}
+
+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)) {
+    throw new Error('@arethetypeswrong/core does not expose the expected API');
+  }
+  const PackageConstructor = core.Package;
+  const checkPackage = core.checkPackage;
+  if (typeof PackageConstructor !== 'function' || typeof checkPackage !== 'function') {
+    throw new Error('@arethetypeswrong/core does not expose the expected API');
+  }
+  return {
+    createPackage: (files, packageName, packageVersion) =>
+      Reflect.construct(PackageConstructor, [files, packageName, packageVersion]),
+    checkPackage: (pkg, options) => Promise.resolve(checkPackage(pkg, options)),
+  };
+}
+
+async function createAttwPackageFromTarball(attw: AttwCore, root: string, tarballPath: string): Promise<unknown> {
+  const temp = mkdtempSync(join(tmpdir(), 'smoo-attw-'));
+  try {
+    const extract = await runResult('tar', ['-xzf', tarballPath, '-C', temp], root);
+    if (extract.exitCode !== 0) {
+      printCommandOutput(extract.stdout, extract.stderr);
+      throw new Error('unable to extract packed package for are-the-types-wrong');
+    }
+    return createAttwPackageFromDirectory(attw, join(temp, 'package'));
+  } finally {
+    rmSync(temp, { recursive: true, force: true });
+  }
+}
+
+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;
+  if (!packageName || !packageVersion) {
+    throw new Error('packed package.json must contain name and version');
+  }
+  const files: Record<string, Uint8Array> = {};
+  collectAttwFiles(packageDir, packageDir, packageName, files);
+  return attw.createPackage(files, packageName, packageVersion);
+}
+
+function collectAttwFiles(root: string, current: string, packageName: string, files: Record<string, Uint8Array>): void {
+  for (const entry of readdirSync(current)) {
+    const path = join(current, entry);
+    const stat = statSync(path);
+    if (stat.isDirectory()) {
+      collectAttwFiles(root, path, packageName, files);
       continue;
     }
-    console.error(line);
+    if (!stat.isFile()) {
+      continue;
+    }
+    const packageRelativePath = relative(root, path).split('\\').join('/');
+    files[`/node_modules/${packageName}/${packageRelativePath}`] = new Uint8Array(readFileSync(path));
+  }
+}
+
+function readJsonFile(path: string): Record<string, unknown> {
+  const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
+  if (!isRecord(parsed)) {
+    throw new Error(`${path} is not a JSON object`);
+  }
+  return parsed;
+}
+
+function isReportedAttwProblem(problem: unknown): boolean {
+  if (!isRecord(problem) || typeof problem.kind !== 'string') {
+    return false;
+  }
+  const flag = attwProblemFlag(problem.kind);
+  if (flag === 'cjs-resolves-to-esm') {
+    return false;
   }
+  return problem.resolutionKind !== 'node10';
 }
 
-function attwExcludedEntrypointArgs(pkg: PackageInfo): string[] {
-  const excluded = wasmExportEntrypoints(pkg.json.exports);
-  return excluded.length === 0 ? [] : ['--exclude-entrypoints', ...excluded];
+function attwProblemFlag(kind: string): string | null {
+  switch (kind) {
+    case 'NoResolution':
+      return 'no-resolution';
+    case 'UntypedResolution':
+      return 'untyped-resolution';
+    case 'FalseCJS':
+      return 'false-cjs';
+    case 'FalseESM':
+      return 'false-esm';
+    case 'CJSResolvesToESM':
+      return 'cjs-resolves-to-esm';
+    case 'FallbackCondition':
+      return 'fallback-condition';
+    case 'CJSOnlyExportsDefault':
+      return 'cjs-only-exports-default';
+    case 'NamedExports':
+      return 'named-exports';
+    case 'FalseExportDefault':
+      return 'false-export-default';
+    case 'MissingExportEquals':
+      return 'missing-export-equals';
+    case 'UnexpectedModuleSyntax':
+      return 'unexpected-module-syntax';
+    case 'InternalResolutionError':
+      return 'internal-resolution-error';
+    default:
+      return null;
+  }
+}
+
+function formatProblemLocation(problem: unknown): string {
+  if (!isRecord(problem)) {
+    return '';
+  }
+  const entrypoint = typeof problem.entrypoint === 'string' ? ` ${problem.entrypoint}` : '';
+  const resolution =
+    typeof problem.resolutionKind === 'string' ? ` ${formatResolutionKind(problem.resolutionKind)}` : '';
+  return `${entrypoint}${resolution}`;
+}
+
+function formatResolutionKind(kind: string): string {
+  if (kind === 'node16-cjs') {
+    return 'node16 (from CJS)';
+  }
+  if (kind === 'node16-esm') {
+    return 'node16 (from ESM)';
+  }
+  return kind;
 }
 
 function wasmExportEntrypoints(exports: unknown): string[] {

package/src/pr/index.test.ts

@@ -0,0 +1,187 @@
+import { afterEach, beforeEach, describe, expect, it, spyOn } from 'bun:test';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { type PrResolveShell, resolvePrConflicts } from './index.js';
+
+let gitDir: string;
+
+beforeEach(() => {
+  gitDir = mkdtempSync(join(tmpdir(), 'smoo-pr-'));
+  spyOn(console, 'log').mockImplementation(() => {});
+  spyOn(console, 'error').mockImplementation(() => {});
+});
+
+afterEach(() => {
+  rmSync(gitDir, { recursive: true, force: true });
+});
+
+const PR_JSON = JSON.stringify({
+  number: 40,
+  url: 'https://github.com/conloca/private/pull/40',
+  headRefName: 'gar-sync/private-to-public',
+  baseRefName: 'public-mirror',
+  isCrossRepository: false,
+});
+const MARKERED = '{\n<<<<<<< HEAD\n  "a": 1\n=======\n  "a": 2\n>>>>>>> feat\n}\n';
+const CLEAN = '{\n  "a": 1\n}\n';
+
+const statePath = () => join(gitDir, 'smoo', 'pr-resolve.json');
+
+describe('smoo pr resolve — phase A (start)', () => {
+  it('reports clean and writes no state when the PR has no markers', async () => {
+    const shell = scriptedShell([
+      ok(gitDir), // rev-parse --absolute-git-dir
+      ok(''), // status --porcelain (clean tree)
+      ok(PR_JSON), // gh pr view
+      ok('a.json\n'), // diff --name-only base...head
+      ok(CLEAN), // show head:a.json
+    ]);
+    const exit = await resolvePrConflicts('/repo', '40', { remote: 'origin' }, shell.shell);
+    expect(exit).toBe(0);
+    expect(existsSync(statePath())).toBe(false);
+    expect(shell.runCommands).not.toContainEqual(expect.stringContaining('checkout'));
+  });
+
+  it('checks out the branch, saves state, and returns 2 when markers exist', async () => {
+    const shell = scriptedShell([
+      ok(gitDir),
+      ok(''),
+      ok(PR_JSON),
+      ok('a.json\n'),
+      ok(MARKERED),
+      ok('main\n'), // symbolic-ref (current branch)
+      ok('deadbeefcafe\n'), // rev-parse HEAD
+    ]);
+    const exit = await resolvePrConflicts('/repo', '40', { remote: 'origin' }, shell.shell);
+    expect(exit).toBe(2);
+    const state = JSON.parse(readFileSync(statePath(), 'utf8'));
+    expect(state.pr).toBe(40);
+    expect(state.headBranch).toBe('gar-sync/private-to-public');
+    expect(state.originalBranch).toBe('main');
+    expect(state.remote).toBe('origin');
+    expect(shell.runCommands).toContainEqual(
+      'git checkout -B gar-sync/private-to-public origin/gar-sync/private-to-public',
+    );
+  });
+
+  it('refuses to start on a dirty working tree', async () => {
+    const shell = scriptedShell([ok(gitDir), ok(' M src/x.ts\n')]);
+    const exit = await resolvePrConflicts('/repo', '40', { remote: 'origin' }, shell.shell);
+    expect(exit).toBe(1);
+    expect(existsSync(statePath())).toBe(false);
+  });
+});
+
+describe('smoo pr resolve — phase B (finish)', () => {
+  it('pushes and restores the original branch when markers are resolved', async () => {
+    writeState({ originalBranch: 'main' });
+    const shell = scriptedShell([
+      ok(gitDir),
+      ok('gar-sync/private-to-public\n'), // symbolic-ref (on the PR branch)
+      ok(''), // status --porcelain (committed, clean)
+      ok('a.json\n'), // diff --name-only base...HEAD
+      ok(CLEAN), // show HEAD:a.json (resolved)
+      ok(''), // git push (fast-forward)
+    ]);
+    const exit = await resolvePrConflicts('/repo', undefined, {}, shell.shell);
+    expect(exit).toBe(0);
+    expect(existsSync(statePath())).toBe(false);
+    expect(shell.runResultCommands).toContainEqual('git push origin HEAD:refs/heads/gar-sync/private-to-public');
+    expect(shell.runCommands).toContainEqual('git checkout main');
+  });
+
+  it('returns 2 and keeps state when markers still remain', async () => {
+    writeState({ originalBranch: 'main' });
+    const shell = scriptedShell([
+      ok(gitDir),
+      ok('gar-sync/private-to-public\n'),
+      ok(''),
+      ok('a.json\n'),
+      ok(MARKERED), // still markered
+    ]);
+    const exit = await resolvePrConflicts('/repo', undefined, {}, shell.shell);
+    expect(exit).toBe(2);
+    expect(existsSync(statePath())).toBe(true);
+    expect(shell.runResultCommands).not.toContainEqual(expect.stringContaining('push'));
+  });
+
+  it('returns 2 when the resolution is not committed', async () => {
+    writeState({ originalBranch: 'main' });
+    const shell = scriptedShell([ok(gitDir), ok('gar-sync/private-to-public\n'), ok(' M a.json\n')]);
+    const exit = await resolvePrConflicts('/repo', undefined, {}, shell.shell);
+    expect(exit).toBe(2);
+    expect(existsSync(statePath())).toBe(true);
+  });
+
+  it('errors when HEAD is not on the PR branch', async () => {
+    writeState({ originalBranch: 'main' });
+    const shell = scriptedShell([ok(gitDir), ok('some-other-branch\n')]);
+    const exit = await resolvePrConflicts('/repo', undefined, {}, shell.shell);
+    expect(exit).toBe(1);
+    expect(existsSync(statePath())).toBe(true);
+  });
+
+  it('errors when pointed at a different PR mid-resolution', async () => {
+    writeState({ originalBranch: 'main' });
+    const shell = scriptedShell([ok(gitDir)]);
+    const exit = await resolvePrConflicts('/repo', '99', {}, shell.shell);
+    expect(exit).toBe(1);
+  });
+});
+
+describe('smoo pr resolve --abort', () => {
+  it('restores the original branch and clears state', async () => {
+    writeState({ originalBranch: 'main' });
+    const shell = scriptedShell([ok(gitDir)]);
+    const exit = await resolvePrConflicts('/repo', undefined, { abort: true }, shell.shell);
+    expect(exit).toBe(0);
+    expect(existsSync(statePath())).toBe(false);
+    expect(shell.runCommands).toContainEqual('git checkout main');
+  });
+});
+
+function writeState(overrides: Record<string, unknown>): void {
+  mkdirSync(join(gitDir, 'smoo'), { recursive: true });
+  const state = {
+    pr: 40,
+    url: 'https://github.com/conloca/private/pull/40',
+    headBranch: 'gar-sync/private-to-public',
+    baseBranch: 'public-mirror',
+    remote: 'origin',
+    crossRepo: false,
+    originalBranch: 'main',
+    originalSha: 'deadbeefcafe',
+    startedAt: '2026-07-01T00:00:00Z',
+    ...overrides,
+  };
+  writeFileSync(statePath(), `${JSON.stringify(state, null, 2)}\n`);
+}
+
+function ok(stdout: string): { exitCode: number; stdout: string; stderr: string } {
+  return { exitCode: 0, stdout, stderr: '' };
+}
+
+function scriptedShell(responses: { exitCode: number; stdout: string; stderr: string }[]): {
+  shell: PrResolveShell;
+  runCommands: string[];
+  runResultCommands: string[];
+} {
+  const runCommands: string[] = [];
+  const runResultCommands: string[] = [];
+  let index = 0;
+  const shell: PrResolveShell = {
+    async runResult(command, args, _cwd) {
+      runResultCommands.push(`${command} ${args.join(' ')}`);
+      const response = responses[index++];
+      if (!response) {
+        throw new Error(`unexpected runResult call: ${command} ${args.join(' ')}`);
+      }
+      return response;
+    },
+    async run(command, args, _cwd) {
+      runCommands.push(`${command} ${args.join(' ')}`);
+    },
+  };
+  return { shell, runCommands, runResultCommands };
+}