slicejs-web-framework 3.4.4 → 3.5.1

package/slicejs-cli/tests/helpers/setup.js

@@ -1,102 +0,0 @@
-import fs from 'fs-extra'
-import path from 'path'
-import os from 'os'
-import { fileURLToPath } from 'url'
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-// Prefer the sibling framework dev repo when present (local monorepo checkout);
-// otherwise fall back to the installed framework package (e.g. CI, where only
-// this repo is checked out). Both ship the same src/ + api/ starter structure.
-const SIBLING_FW = path.resolve(__dirname, '../../../slice.js')
-const PACKAGE_FW = path.resolve(__dirname, '../../node_modules/slicejs-web-framework')
-const FW_DIR = fs.pathExistsSync(SIBLING_FW) ? SIBLING_FW : PACKAGE_FW
-const FIXTURES_DIR = path.resolve(__dirname, '../fixtures')
-
-let counter = 0
-
-export async function createTestProject(options = {}) {
-  const {
-    visualComponents = [],
-    frameworkDir = FW_DIR,
-  } = options
-
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), `slice-test-${process.pid}-${counter++}-`))
-
-  const fwExists = await fs.pathExists(frameworkDir)
-  const srcDir = path.join(dir, 'src')
-
-  if (fwExists) {
-    const fwSrc = path.join(frameworkDir, 'src')
-    const fwApi = path.join(frameworkDir, 'api')
-
-    if (await fs.pathExists(fwSrc)) {
-      await fs.copy(fwSrc, srcDir)
-    }
-    if (await fs.pathExists(fwApi)) {
-      await fs.copy(fwApi, path.join(dir, 'api'))
-    }
-  }
-
-  if (!(await fs.pathExists(srcDir))) {
-    await createMinimalScaffold(dir)
-  }
-
-  await fs.ensureDir(path.join(srcDir, 'Components', 'Visual'))
-
-  if (visualComponents.length > 0) {
-    const registryLines = visualComponents.map(n => `  "${n}": "Visual"`).join(',\n')
-    await fs.writeFile(
-      path.join(srcDir, 'Components', 'components.js'),
-      `const components = {\n${registryLines}\n}; export default components;\n`
-    )
-    for (const name of visualComponents) {
-      const compDir = path.join(srcDir, 'Components', 'Visual', name)
-      await fs.ensureDir(compDir)
-      await fs.writeFile(path.join(compDir, `${name}.js`), `export default class ${name} {}`)
-    }
-  }
-
-  return dir
-}
-
-export async function cleanupTestProject(dir) {
-  await fs.remove(dir)
-}
-
-export async function withTestProject(fn, options = {}) {
-  const dir = await createTestProject(options)
-  const origInitCwd = process.env.INIT_CWD
-  try {
-    process.env.INIT_CWD = dir
-    return await fn(dir)
-  } finally {
-    if (origInitCwd === undefined) {
-      delete process.env.INIT_CWD
-    } else {
-      process.env.INIT_CWD = origInitCwd
-    }
-    await cleanupTestProject(dir)
-  }
-}
-
-async function createMinimalScaffold(dir) {
-  const srcDir = path.join(dir, 'src')
-  await fs.ensureDir(path.join(srcDir, 'App'))
-  await fs.ensureDir(path.join(srcDir, 'Components', 'AppComponents', 'AppShell'))
-  await fs.ensureDir(path.join(srcDir, 'Components', 'Service', 'FetchManager'))
-  await fs.ensureDir(path.join(srcDir, 'Components', 'Visual'))
-  await fs.ensureDir(path.join(srcDir, 'Styles'))
-  await fs.ensureDir(path.join(srcDir, 'Themes'))
-  await fs.ensureDir(path.join(dir, 'api', 'middleware'))
-  await fs.ensureDir(path.join(dir, 'api', 'utils'))
-
-  const fixtureConfig = path.join(FIXTURES_DIR, 'sliceConfig.json')
-  if (await fs.pathExists(fixtureConfig)) {
-    await fs.copy(fixtureConfig, path.join(srcDir, 'sliceConfig.json'))
-  }
-
-  const fixtureComponents = path.join(FIXTURES_DIR, 'components.js')
-  if (await fs.pathExists(fixtureComponents)) {
-    await fs.copy(fixtureComponents, path.join(srcDir, 'Components', 'components.js'))
-  }
-}

package/slicejs-cli/tests/init-command-contract.test.js

@@ -1,101 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const clientPath = path.join(__dirname, '..', 'client.js');
-const source = fs.readFileSync(clientPath, 'utf-8');
-
-test('init command is registered in client.js', () => {
-  const hasInit = source.includes('.command("init")');
-  assert.ok(hasInit, 'client.js must register an "init" command');
-});
-
-test('init command has a description', () => {
-  const match = source.match(/\.command\(["']init["']\)\s*\.description\(["']([^"']+)["']\)/);
-  assert.ok(match, 'init command must have a .description() call');
-  assert.ok(match[1].length > 0, 'init command description must not be empty');
-});
-
-test('init command has -y / --yes option', () => {
-  const hasShort = source.includes('"-y, --yes');
-  assert.ok(hasShort, 'init command must have a -y/--yes option for non-interactive use');
-});
-
-test('init command action calls initializeProject with the chosen package manager', () => {
-  const hasCall = source.includes('initializeProject({ packageManager })');
-  assert.ok(hasCall, 'init command action must call initializeProject passing the package manager');
-});
-
-test('init command has a --pm option for package manager selection', () => {
-  assert.ok(source.includes('--pm <packageManager>'), 'init command must expose a --pm option');
-});
-
-test('init command normalizes project name (lowercase, hyphens)', () => {
-  const hasFilter = source.includes('.toLowerCase()');
-  assert.ok(hasFilter, 'init command must normalize project name to lowercase');
-  assert.ok(source.includes('.replace(/\\s+/g'), 'init command must replace spaces with hyphens');
-});
-
-test('init command validates project name', () => {
-  assert.ok(source.includes("'Project name cannot be empty'"), 'init command must validate non-empty name');
-  assert.ok(source.includes("'Use a simple name, not a path'"), 'init command must reject path separators');
-});
-
-test('init command creates project directory', () => {
-  assert.ok(source.includes('fs.mkdirSync(projectDir'), 'init command must create the project directory');
-  assert.ok(source.includes('process.chdir(projectDir)'), 'init command must chdir into project');
-});
-
-// --- initializeProject (commands/init/init.js) contracts ---
-
-const initPath = path.join(__dirname, '..', 'commands', 'init', 'init.js');
-const initSource = fs.readFileSync(initPath, 'utf-8');
-
-test('initializeProject creates package.json BEFORE installing anything', () => {
-  // Without a manifest in the project folder, npm/pnpm walk up the directory
-  // tree and anchor node_modules OUTSIDE the new project. The manifest must
-  // exist before the first install command runs.
-  const manifestIdx = initSource.indexOf('await ensureProjectManifest(');
-  const installIdx = initSource.indexOf('execSync(installCommand(');
-  assert.ok(manifestIdx !== -1, 'init.js must call ensureProjectManifest');
-  assert.ok(installIdx !== -1, 'init.js must install via PackageManager.installCommand');
-  assert.ok(manifestIdx < installIdx, 'package.json must be created before any install runs');
-});
-
-test('initializeProject does not hardcode npm commands', () => {
-  assert.ok(!initSource.includes("execSync('npm "), 'init.js must not execSync hardcoded npm commands');
-  assert.ok(!initSource.includes('execSync(`npm '), 'init.js must not execSync hardcoded npm template commands');
-});
-
-test('initializeProject resolves and installs exact framework/cli versions', () => {
-  assert.ok(initSource.includes('fetchLatestVersion(\'slicejs-web-framework\')'), 'init.js must resolve latest framework version');
-  assert.ok(initSource.includes('slicejs-web-framework@${latestVersion}'), 'init.js must build exact framework package spec');
-  assert.ok(initSource.includes('getRunningCliVersion()'), 'init.js must resolve running CLI version');
-  assert.ok(initSource.includes('slicejs-cli@${currentCliVersion}'), 'init.js must build exact CLI package spec');
-});
-
-test('initializeProject installs slicejs-cli as devDependency', () => {
-  assert.ok(
-    initSource.includes("installCommand(packageManager, cliPackage, { dev: true })"),
-    'init.js must install slicejs-cli locally as a devDependency'
-  );
-});
-
-test('initializeProject persists the packageManager field', () => {
-  assert.ok(initSource.includes('pkg.packageManager ='), 'init.js must persist the packageManager field in package.json');
-});
-
-test('initializeProject configures pnpm allowBuilds for slicejs-cli', () => {
-  assert.ok(
-    initSource.includes("if (packageManager === 'pnpm')")
-      && initSource.includes('ensurePnpmAllowBuilds(projectRoot)'),
-    'init.js must configure pnpm allowBuilds when pnpm is selected'
-  );
-  assert.ok(
-    initSource.includes("allowBuilds:") && initSource.includes("slicejs-cli: true"),
-    'init.js must write allowBuilds.slicejs-cli: true in pnpm-workspace.yaml'
-  );
-});

package/slicejs-cli/tests/init-e2e.test.js

@@ -1,82 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'fs-extra';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { spawnSync } from 'node:child_process';
-import { isPackageManagerAvailable } from '../commands/utils/PackageManager.js';
-import { SLICE_SCRIPTS } from '../commands/utils/sliceScripts.js';
-
-// REAL end-to-end test of `slice init`: spawns the actual CLI, installs real
-// packages from the registry and downloads starter components from GitHub.
-// Needs network and takes ~1-2 minutes, so it is opt-in:
-//
-//   SLICE_INIT_E2E=1 node --test tests/init-e2e.test.js
-//
-const E2E_ENABLED = process.env.SLICE_INIT_E2E === '1';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const CLIENT = path.join(__dirname, '..', 'client.js');
-
-test('slice init -y creates a fully self-contained project (real run)', { skip: !E2E_ENABLED && 'set SLICE_INIT_E2E=1 to run' }, async () => {
-  const pm = ['pnpm', 'npm'].find(isPackageManagerAvailable);
-  assert.ok(pm, 'a package manager must be available');
-
-  // Parent directory WITH a package.json — the ancestor the old code leaked into.
-  const parent = await fs.mkdtemp(path.join(os.tmpdir(), 'slice-init-e2e-'));
-  const parentManifest = { name: 'parent-trap', version: '1.0.0' };
-  await fs.writeJson(path.join(parent, 'package.json'), parentManifest);
-
-  try {
-    const result = spawnSync(process.execPath, [CLIENT, 'init', '-y', 'demo-app', '--pm', pm], {
-      cwd: parent,
-      encoding: 'utf-8',
-      env: { ...process.env, SLICE_NO_LOCAL_DELEGATION: '1' },
-      timeout: 600_000
-    });
-
-    const output = `${result.stdout}\n${result.stderr}`;
-    assert.equal(result.status, 0, `init must exit 0. Output:\n${output}`);
-
-    const projectDir = path.join(parent, 'demo-app');
-
-    // Everything must live INSIDE the project folder…
-    const pkg = await fs.readJson(path.join(projectDir, 'package.json'));
-    assert.equal(pkg.name, 'demo-app');
-    assert.ok(pkg.packageManager?.startsWith(`${pm}@`), 'packageManager field must pin the chosen PM');
-    assert.ok(pkg.dependencies?.['slicejs-web-framework'], 'framework must be a dependency');
-    assert.ok(pkg.devDependencies?.['slicejs-cli'], 'CLI must be a devDependency');
-    assert.equal(pkg.scripts?.dev, SLICE_SCRIPTS['slice:dev']);
-    assert.equal(pkg.scripts?.build, SLICE_SCRIPTS['slice:build']);
-    assert.equal(pkg.scripts?.start, SLICE_SCRIPTS['slice:start']);
-    for (const [script, command] of Object.entries(SLICE_SCRIPTS)) {
-      assert.equal(pkg.scripts?.[script], command, `script ${script} must be configured`);
-    }
-
-    assert.ok(await fs.pathExists(path.join(projectDir, 'node_modules', 'slicejs-web-framework', 'package.json')),
-      'framework must be installed inside the project');
-    assert.ok(await fs.pathExists(path.join(projectDir, 'node_modules', 'slicejs-cli', 'package.json')),
-      'CLI must be installed inside the project');
-
-    const lockfile = pm === 'pnpm' ? 'pnpm-lock.yaml' : 'package-lock.json';
-    assert.ok(await fs.pathExists(path.join(projectDir, lockfile)), `${lockfile} must be inside the project`);
-
-    assert.ok(await fs.pathExists(path.join(projectDir, 'src', 'sliceConfig.json')), 'src/ structure must exist');
-    assert.ok(await fs.pathExists(path.join(projectDir, 'api', 'index.js')), 'api/ structure must exist');
-
-    const componentsJs = await fs.readFile(path.join(projectDir, 'src', 'Components', 'components.js'), 'utf-8');
-    for (const name of ['Button', 'MultiRoute', 'Navbar', 'FetchManager']) {
-      assert.ok(componentsJs.includes(name), `starter component ${name} must be registered`);
-    }
-
-    // …and the parent must be untouched: same manifest, no node_modules, no lockfile.
-    assert.deepEqual(await fs.readJson(path.join(parent, 'package.json')), parentManifest,
-      'parent package.json must be untouched');
-    assert.ok(!(await fs.pathExists(path.join(parent, 'node_modules'))), 'no node_modules may leak into the parent');
-    assert.ok(!(await fs.pathExists(path.join(parent, 'pnpm-lock.yaml'))), 'no lockfile may leak into the parent');
-    assert.ok(!(await fs.pathExists(path.join(parent, 'package-lock.json'))), 'no lockfile may leak into the parent');
-  } finally {
-    await fs.remove(parent);
-  }
-});

package/slicejs-cli/tests/init-project-isolation.test.js

@@ -1,98 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'fs-extra';
-import os from 'node:os';
-import path from 'node:path';
-import { execSync } from 'node:child_process';
-import { ensureProjectManifest } from '../commands/init/init.js';
-import { getPackageManagerVersion, isPackageManagerAvailable } from '../commands/utils/PackageManager.js';
-
-// Regression tests for the "two package.json" bug: `slice init` used to run the
-// framework install BEFORE writing the project manifest, so npm/pnpm walked up
-// the directory tree and anchored node_modules + the dependency entry in an
-// ancestor's package.json (outside the new project folder).
-
-async function makeParentTrap() {
-  // Parent directory WITH a package.json — the ancestor npm/pnpm would walk up to.
-  const parent = await fs.mkdtemp(path.join(os.tmpdir(), 'slice-init-isolation-'));
-  await fs.writeJson(path.join(parent, 'package.json'), { name: 'parent-trap', version: '1.0.0' });
-  const projectDir = path.join(parent, 'demo-app');
-  await fs.ensureDir(projectDir);
-  return { parent, projectDir };
-}
-
-test('ensureProjectManifest creates package.json inside the project folder', async () => {
-  const { parent, projectDir } = await makeParentTrap();
-  try {
-    await ensureProjectManifest(projectDir, 'npm');
-
-    const pkgPath = path.join(projectDir, 'package.json');
-    assert.ok(await fs.pathExists(pkgPath), 'package.json must exist inside the project folder');
-
-    const pkg = await fs.readJson(pkgPath);
-    assert.equal(pkg.name, 'demo-app');
-    assert.equal(pkg.type, 'module');
-
-    // Parent manifest untouched
-    const parentPkg = await fs.readJson(path.join(parent, 'package.json'));
-    assert.deepEqual(parentPkg, { name: 'parent-trap', version: '1.0.0' });
-  } finally {
-    await fs.remove(parent);
-  }
-});
-
-test('ensureProjectManifest persists the packageManager field when the PM version is known', async (t) => {
-  const pm = ['pnpm', 'npm'].find(isPackageManagerAvailable);
-  if (!pm) {
-    t.skip('no package manager binary available');
-    return;
-  }
-  const { parent, projectDir } = await makeParentTrap();
-  try {
-    await ensureProjectManifest(projectDir, pm);
-    const pkg = await fs.readJson(path.join(projectDir, 'package.json'));
-    const version = getPackageManagerVersion(pm);
-    if (version) {
-      assert.equal(pkg.packageManager, `${pm}@${version}`);
-    }
-  } finally {
-    await fs.remove(parent);
-  }
-});
-
-test('ensureProjectManifest does not overwrite an existing manifest', async () => {
-  const { parent, projectDir } = await makeParentTrap();
-  try {
-    const existing = { name: 'keep-me', version: '2.0.0', scripts: { custom: 'echo hi' } };
-    await fs.writeJson(path.join(projectDir, 'package.json'), existing);
-
-    await ensureProjectManifest(projectDir, 'npm');
-
-    const pkg = await fs.readJson(path.join(projectDir, 'package.json'));
-    assert.deepEqual(pkg, existing, 'an existing package.json must be left untouched');
-  } finally {
-    await fs.remove(parent);
-  }
-});
-
-test('with the manifest in place, the package manager anchors to the project folder (not the parent)', async (t) => {
-  // `npm prefix` resolves the nearest package.json from cwd — exactly the
-  // walk-up mechanism that caused the bug. No install or network needed.
-  if (!isPackageManagerAvailable('npm')) {
-    t.skip('npm binary not available');
-    return;
-  }
-  const { parent, projectDir } = await makeParentTrap();
-  try {
-    // Without a manifest, npm anchors to the parent trap…
-    const before = execSync('npm prefix', { cwd: projectDir, encoding: 'utf-8' }).trim();
-    assert.equal(await fs.realpath(before), await fs.realpath(parent), 'precondition: npm walks up without a manifest');
-
-    // …and with the manifest created first, it anchors to the project folder.
-    await ensureProjectManifest(projectDir, 'npm');
-    const after = execSync('npm prefix', { cwd: projectDir, encoding: 'utf-8' }).trim();
-    assert.equal(await fs.realpath(after), await fs.realpath(projectDir), 'npm must anchor inside the project folder');
-  } finally {
-    await fs.remove(parent);
-  }
-});

package/slicejs-cli/tests/local-cli-delegation.test.js

@@ -1,81 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  findNearestLocalCliEntry,
-  resolveLocalCliCandidate,
-  shouldDelegateToLocalCli,
-  isLocalDelegationDisabled
-} from '../commands/utils/LocalCliDelegation.js';
-
-test('isLocalDelegationDisabled returns true when env flag is set', () => {
-  const env = { SLICE_NO_LOCAL_DELEGATION: '1' };
-  assert.equal(isLocalDelegationDisabled(env), true);
-});
-
-test('isLocalDelegationDisabled returns false when env flag is missing', () => {
-  const env = {};
-  assert.equal(isLocalDelegationDisabled(env), false);
-});
-
-test('shouldDelegateToLocalCli is false when candidate is null', () => {
-  assert.equal(shouldDelegateToLocalCli('/tmp/current/client.js', null), false);
-});
-
-test('shouldDelegateToLocalCli is false when candidate realpath equals current realpath', () => {
-  const same = '/tmp/current/client.js';
-  assert.equal(shouldDelegateToLocalCli(same, same), false);
-});
-
-test('shouldDelegateToLocalCli is true when candidate differs from current', () => {
-  const current = '/tmp/global/client.js';
-  const local = '/tmp/project/node_modules/slicejs-cli/client.js';
-  assert.equal(shouldDelegateToLocalCli(current, local), true);
-});
-
-test('findNearestLocalCliEntry returns null when no candidate resolver hits', () => {
-  const cwd = path.join('/tmp', 'slice-nonexistent-project');
-  const resolver = () => null;
-  const result = findNearestLocalCliEntry(cwd, resolver);
-  assert.equal(result, null);
-});
-
-test('findNearestLocalCliEntry returns first match while traversing upward', () => {
-  const cwd = path.resolve('/repo/apps/web/src');
-  const matchDir = path.resolve('/repo/apps/web');
-  const matchResult = path.resolve('/repo/apps/web/node_modules/slicejs-cli/client.js');
-  const calls = [];
-  const resolver = (dir) => {
-    calls.push(dir);
-    if (dir === matchDir) {
-      return matchResult;
-    }
-    return null;
-  };
-
-  const result = findNearestLocalCliEntry(cwd, resolver);
-
-  assert.equal(result, matchResult);
-  assert.deepEqual(calls, [cwd, matchDir]);
-});
-
-test('findNearestLocalCliEntry returns null when resolver is not a function', () => {
-  const result = findNearestLocalCliEntry('/repo/apps/web/src', null);
-  assert.equal(result, null);
-});
-
-test('resolveLocalCliCandidate returns null when candidate path is a directory', () => {
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'slice-cli-delegation-'));
-  const candidateDirectory = path.join(tempRoot, 'node_modules', 'slicejs-cli', 'client.js');
-
-  fs.mkdirSync(candidateDirectory, { recursive: true });
-
-  try {
-    const result = resolveLocalCliCandidate(tempRoot);
-    assert.equal(result, null);
-  } finally {
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-  }
-});

package/slicejs-cli/tests/package-manager.test.js

@@ -1,127 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  parseUserAgent,
-  fromPackageManagerField,
-  fromLockfile,
-  detectPackageManager,
-  resolvePackageManager,
-  installCommand,
-  uninstallCommand,
-  SUPPORTED_PACKAGE_MANAGERS
-} from '../commands/utils/PackageManager.js';
-
-function makeTmpDir() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'slice-pm-test-'));
-}
-
-test('parseUserAgent detects pnpm', () => {
-  const result = parseUserAgent('pnpm/9.12.0 npm/? node/v20.11.0 linux x64');
-  assert.equal(result.name, 'pnpm');
-  assert.equal(result.version, '9.12.0');
-});
-
-test('parseUserAgent detects npm', () => {
-  const result = parseUserAgent('npm/10.5.0 node/v20.11.0 linux x64 workspaces/false');
-  assert.equal(result.name, 'npm');
-});
-
-test('parseUserAgent returns null for missing or unknown agent', () => {
-  assert.equal(parseUserAgent(null), null);
-  assert.equal(parseUserAgent('bun/1.1.0 node/v20.11.0'), null);
-  assert.equal(parseUserAgent('yarn/1.22.22 node/v20.11.0'), null);
-});
-
-test('fromPackageManagerField reads corepack-style field', () => {
-  const dir = makeTmpDir();
-  try {
-    fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'x', packageManager: 'pnpm@9.12.0' }));
-    const result = fromPackageManagerField(dir);
-    assert.equal(result.name, 'pnpm');
-    assert.equal(result.version, '9.12.0');
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('fromPackageManagerField returns null without field or manifest', () => {
-  const dir = makeTmpDir();
-  try {
-    assert.equal(fromPackageManagerField(dir), null);
-    fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'x' }));
-    assert.equal(fromPackageManagerField(dir), null);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('fromLockfile detects each supported lockfile', () => {
-  const cases = [
-    ['pnpm-lock.yaml', 'pnpm'],
-    ['package-lock.json', 'npm']
-  ];
-  for (const [lockfile, expected] of cases) {
-    const dir = makeTmpDir();
-    try {
-      fs.writeFileSync(path.join(dir, lockfile), '');
-      assert.equal(fromLockfile(dir).name, expected, `${lockfile} should map to ${expected}`);
-    } finally {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  }
-});
-
-test('detectPackageManager prefers packageManager field over lockfile and user agent', () => {
-  const dir = makeTmpDir();
-  try {
-    fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'x', packageManager: 'pnpm@9.0.0' }));
-    fs.writeFileSync(path.join(dir, 'package-lock.json'), '{}');
-    const result = detectPackageManager(dir, { userAgent: 'npm/10.5.0 node/v20.11.0' });
-    assert.equal(result.name, 'pnpm');
-    assert.equal(result.source, 'package-manager-field');
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('detectPackageManager falls back to lockfile, then user agent', () => {
-  const dir = makeTmpDir();
-  try {
-    fs.writeFileSync(path.join(dir, 'pnpm-lock.yaml'), '');
-    assert.equal(detectPackageManager(dir, { userAgent: 'npm/10.5.0 node/v20' }).name, 'pnpm');
-    fs.rmSync(path.join(dir, 'pnpm-lock.yaml'));
-    assert.equal(detectPackageManager(dir, { userAgent: 'npm/10.5.0 node/v20' }).name, 'npm');
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('resolvePackageManager never returns null', () => {
-  const dir = makeTmpDir();
-  try {
-    const result = resolvePackageManager(dir, { userAgent: undefined });
-    assert.ok(SUPPORTED_PACKAGE_MANAGERS.includes(result.name));
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('installCommand builds the right command per package manager', () => {
-  assert.equal(installCommand('npm', 'slicejs-web-framework'), 'npm install slicejs-web-framework');
-  assert.equal(installCommand('pnpm', 'slicejs-web-framework'), 'pnpm add slicejs-web-framework');
-  assert.equal(installCommand('npm', 'slicejs-cli', { dev: true }), 'npm install -D slicejs-cli');
-  assert.equal(installCommand('pnpm', 'slicejs-cli', { dev: true }), 'pnpm add -D slicejs-cli');
-  assert.equal(installCommand('npm', 'slicejs-cli@latest', { global: true }), 'npm install -g slicejs-cli@latest');
-  assert.equal(installCommand('pnpm', 'slicejs-cli@latest', { global: true }), 'pnpm add -g slicejs-cli@latest');
-  assert.equal(installCommand('pnpm', ['a', 'b']), 'pnpm add a b');
-});
-
-test('uninstallCommand builds the right command per package manager', () => {
-  assert.equal(uninstallCommand('npm', 'slicejs-cli'), 'npm uninstall slicejs-cli');
-  assert.equal(uninstallCommand('pnpm', 'slicejs-cli'), 'pnpm remove slicejs-cli');
-  assert.equal(uninstallCommand('pnpm', 'slicejs-cli', { global: true }), 'pnpm remove -g slicejs-cli');
-  assert.equal(uninstallCommand('npm', 'slicejs-cli', { global: true }), 'npm uninstall -g slicejs-cli');
-});