slicejs-cli 3.6.2 → 3.6.4

package/commands/utils/LocalCliDelegation.js

@@ -1,53 +1,53 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-function getParentDirectory(dir) {
-  const parent = path.dirname(dir);
-  return parent === dir ? null : parent;
-}
-
-export function isLocalDelegationDisabled(env = process.env) {
-  return env.SLICE_NO_LOCAL_DELEGATION === '1';
-}
-
-export function findNearestLocalCliEntry(startDirectory, resolveCandidate) {
-  if (!startDirectory || typeof resolveCandidate !== 'function') {
-    return null;
-  }
-
-  let current = path.resolve(startDirectory);
-  while (current) {
-    const candidate = resolveCandidate(current);
-    if (candidate) {
-      return candidate;
-    }
-    current = getParentDirectory(current);
-  }
-
-  return null;
-}
-
-export function resolveLocalCliCandidate(directory) {
-  const candidate = path.join(directory, 'node_modules', 'slicejs-cli', 'client.js');
-
-  try {
-    const stats = fs.statSync(candidate);
-    return stats.isFile() ? candidate : null;
-  } catch {
-    return null;
-  }
-}
-
-export function shouldDelegateToLocalCli(currentEntryPath, localEntryPath) {
-  if (!localEntryPath) {
-    return false;
-  }
-
-  try {
-    const currentReal = fs.realpathSync(currentEntryPath);
-    const localReal = fs.realpathSync(localEntryPath);
-    return currentReal !== localReal;
-  } catch {
-    return path.resolve(currentEntryPath) !== path.resolve(localEntryPath);
-  }
-}
+import fs from 'node:fs';
+import path from 'node:path';
+
+function getParentDirectory(dir) {
+  const parent = path.dirname(dir);
+  return parent === dir ? null : parent;
+}
+
+export function isLocalDelegationDisabled(env = process.env) {
+  return env.SLICE_NO_LOCAL_DELEGATION === '1';
+}
+
+export function findNearestLocalCliEntry(startDirectory, resolveCandidate) {
+  if (!startDirectory || typeof resolveCandidate !== 'function') {
+    return null;
+  }
+
+  let current = path.resolve(startDirectory);
+  while (current) {
+    const candidate = resolveCandidate(current);
+    if (candidate) {
+      return candidate;
+    }
+    current = getParentDirectory(current);
+  }
+
+  return null;
+}
+
+export function resolveLocalCliCandidate(directory) {
+  const candidate = path.join(directory, 'node_modules', 'slicejs-cli', 'client.js');
+
+  try {
+    const stats = fs.statSync(candidate);
+    return stats.isFile() ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+
+export function shouldDelegateToLocalCli(currentEntryPath, localEntryPath) {
+  if (!localEntryPath) {
+    return false;
+  }
+
+  try {
+    const currentReal = fs.realpathSync(currentEntryPath);
+    const localReal = fs.realpathSync(localEntryPath);
+    return currentReal !== localReal;
+  } catch {
+    return path.resolve(currentEntryPath) !== path.resolve(localEntryPath);
+  }
+}

package/commands/utils/PackageManager.js

@@ -1,148 +1,148 @@
-// commands/utils/PackageManager.js
-//
-// Package manager detection and command building (pnpm / npm).
-// Resolution priority for an existing project:
-//   1. "packageManager" field in the project package.json (corepack convention)
-//   2. Lockfile present at the project root
-//   3. npm_config_user_agent (set when the CLI runs via `npx` / `pnpm dlx` / a PM script)
-//   4. The only PM binary available on PATH (if exactly one)
-// When everything is ambiguous, detectPackageManager() returns null so callers
-// can prompt the user (interactive init) or fall back to pnpm (non-interactive).
-
-import fs from 'fs-extra'
-import path from 'path'
-import { spawnSync } from 'node:child_process'
-
-export const SUPPORTED_PACKAGE_MANAGERS = ['pnpm', 'npm']
-
-const LOCKFILES = {
-  'pnpm-lock.yaml': 'pnpm',
-  'package-lock.json': 'npm'
-}
-
-export function parseUserAgent(userAgent = process.env.npm_config_user_agent) {
-  if (!userAgent) return null
-  const match = userAgent.match(/^(npm|pnpm)\/(\S+)/)
-  if (!match) return null
-  return { name: match[1], version: match[2], source: 'user-agent' }
-}
-
-export function fromPackageManagerField(projectRoot) {
-  try {
-    const pkgPath = path.join(projectRoot, 'package.json')
-    if (!fs.pathExistsSync(pkgPath)) return null
-    const pkg = fs.readJsonSync(pkgPath)
-    if (typeof pkg.packageManager !== 'string') return null
-    const match = pkg.packageManager.match(/^(npm|pnpm)@(\S+)/)
-    if (!match) return null
-    return { name: match[1], version: match[2], source: 'package-manager-field' }
-  } catch {
-    return null
-  }
-}
-
-export function fromLockfile(projectRoot) {
-  for (const [lockfile, name] of Object.entries(LOCKFILES)) {
-    if (fs.pathExistsSync(path.join(projectRoot, lockfile))) {
-      return { name, version: null, source: `lockfile (${lockfile})` }
-    }
-  }
-  return null
-}
-
-function runPmBinary(name, args) {
-  // On Windows the PM entry points are .cmd shims, which require shell resolution.
-  const isWindows = process.platform === 'win32'
-  return spawnSync(name, args, {
-    stdio: ['ignore', 'pipe', 'ignore'],
-    shell: isWindows,
-    encoding: 'utf-8'
-  })
-}
-
-export function isPackageManagerAvailable(name) {
-  try {
-    const result = runPmBinary(name, ['--version'])
-    return result.status === 0
-  } catch {
-    return false
-  }
-}
-
-export function getPackageManagerVersion(name) {
-  try {
-    const result = runPmBinary(name, ['--version'])
-    if (result.status !== 0) return null
-    return (result.stdout || '').toString().trim() || null
-  } catch {
-    return null
-  }
-}
-
-export function getAvailablePackageManagers() {
-  return SUPPORTED_PACKAGE_MANAGERS.filter(isPackageManagerAvailable)
-}
-
-/**
- * Detect the package manager for a project.
- * Returns { name, version, source } or null when genuinely ambiguous.
- */
-export function detectPackageManager(projectRoot, { userAgent = process.env.npm_config_user_agent } = {}) {
-  if (projectRoot) {
-    const fromField = fromPackageManagerField(projectRoot)
-    if (fromField) return fromField
-
-    const fromLock = fromLockfile(projectRoot)
-    if (fromLock) return fromLock
-  }
-
-  const fromUa = parseUserAgent(userAgent)
-  if (fromUa) return fromUa
-
-  const available = getAvailablePackageManagers()
-  if (available.length === 1) {
-    return { name: available[0], version: null, source: 'only available binary' }
-  }
-
-  return null
-}
-
-/**
- * Non-interactive resolution: detection first, then pnpm if available,
- * then whatever binary exists. Never returns null so update/doctor flows
- * always have a usable PM name (commands fail later with a clear error
- * if no PM is actually installed).
- */
-export function resolvePackageManager(projectRoot, options = {}) {
-  const detected = detectPackageManager(projectRoot, options)
-  if (detected) return detected
-
-  const available = getAvailablePackageManagers()
-  if (available.includes('pnpm')) return { name: 'pnpm', version: null, source: 'fallback' }
-  if (available.includes('npm')) return { name: 'npm', version: null, source: 'fallback' }
-  if (available.length > 0) return { name: available[0], version: null, source: 'fallback' }
-  return { name: 'pnpm', version: null, source: 'fallback (none detected)' }
-}
-
-export function installCommand(pmName, packages, { dev = false, global: isGlobal = false } = {}) {
-  const pkgs = Array.isArray(packages) ? packages.join(' ') : packages
-  const flags = [isGlobal ? '-g' : '', dev ? '-D' : ''].filter(Boolean).join(' ')
-  const flagSuffix = flags ? ` ${flags}` : ''
-  if (pmName === 'pnpm') {
-    return `${pmName} add${flagSuffix} ${pkgs}`
-  }
-  return `npm install${flagSuffix} ${pkgs}`
-}
-
-export function uninstallCommand(pmName, packages, { global: isGlobal = false } = {}) {
-  const pkgs = Array.isArray(packages) ? packages.join(' ') : packages
-  const flagSuffix = isGlobal ? ' -g' : ''
-  if (pmName === 'pnpm') {
-    return `${pmName} remove${flagSuffix} ${pkgs}`
-  }
-  return `npm uninstall${flagSuffix} ${pkgs}`
-}
-
-export function runScriptCommand(pmName, script) {
-  return `${pmName} run ${script}`
-}
+// commands/utils/PackageManager.js
+//
+// Package manager detection and command building (pnpm / npm).
+// Resolution priority for an existing project:
+//   1. "packageManager" field in the project package.json (corepack convention)
+//   2. Lockfile present at the project root
+//   3. npm_config_user_agent (set when the CLI runs via `npx` / `pnpm dlx` / a PM script)
+//   4. The only PM binary available on PATH (if exactly one)
+// When everything is ambiguous, detectPackageManager() returns null so callers
+// can prompt the user (interactive init) or fall back to pnpm (non-interactive).
+
+import fs from 'fs-extra'
+import path from 'path'
+import { spawnSync } from 'node:child_process'
+
+export const SUPPORTED_PACKAGE_MANAGERS = ['pnpm', 'npm']
+
+const LOCKFILES = {
+  'pnpm-lock.yaml': 'pnpm',
+  'package-lock.json': 'npm'
+}
+
+export function parseUserAgent(userAgent = process.env.npm_config_user_agent) {
+  if (!userAgent) return null
+  const match = userAgent.match(/^(npm|pnpm)\/(\S+)/)
+  if (!match) return null
+  return { name: match[1], version: match[2], source: 'user-agent' }
+}
+
+export function fromPackageManagerField(projectRoot) {
+  try {
+    const pkgPath = path.join(projectRoot, 'package.json')
+    if (!fs.pathExistsSync(pkgPath)) return null
+    const pkg = fs.readJsonSync(pkgPath)
+    if (typeof pkg.packageManager !== 'string') return null
+    const match = pkg.packageManager.match(/^(npm|pnpm)@(\S+)/)
+    if (!match) return null
+    return { name: match[1], version: match[2], source: 'package-manager-field' }
+  } catch {
+    return null
+  }
+}
+
+export function fromLockfile(projectRoot) {
+  for (const [lockfile, name] of Object.entries(LOCKFILES)) {
+    if (fs.pathExistsSync(path.join(projectRoot, lockfile))) {
+      return { name, version: null, source: `lockfile (${lockfile})` }
+    }
+  }
+  return null
+}
+
+function runPmBinary(name, args) {
+  // On Windows the PM entry points are .cmd shims, which require shell resolution.
+  const isWindows = process.platform === 'win32'
+  return spawnSync(name, args, {
+    stdio: ['ignore', 'pipe', 'ignore'],
+    shell: isWindows,
+    encoding: 'utf-8'
+  })
+}
+
+export function isPackageManagerAvailable(name) {
+  try {
+    const result = runPmBinary(name, ['--version'])
+    return result.status === 0
+  } catch {
+    return false
+  }
+}
+
+export function getPackageManagerVersion(name) {
+  try {
+    const result = runPmBinary(name, ['--version'])
+    if (result.status !== 0) return null
+    return (result.stdout || '').toString().trim() || null
+  } catch {
+    return null
+  }
+}
+
+export function getAvailablePackageManagers() {
+  return SUPPORTED_PACKAGE_MANAGERS.filter(isPackageManagerAvailable)
+}
+
+/**
+ * Detect the package manager for a project.
+ * Returns { name, version, source } or null when genuinely ambiguous.
+ */
+export function detectPackageManager(projectRoot, { userAgent = process.env.npm_config_user_agent } = {}) {
+  if (projectRoot) {
+    const fromField = fromPackageManagerField(projectRoot)
+    if (fromField) return fromField
+
+    const fromLock = fromLockfile(projectRoot)
+    if (fromLock) return fromLock
+  }
+
+  const fromUa = parseUserAgent(userAgent)
+  if (fromUa) return fromUa
+
+  const available = getAvailablePackageManagers()
+  if (available.length === 1) {
+    return { name: available[0], version: null, source: 'only available binary' }
+  }
+
+  return null
+}
+
+/**
+ * Non-interactive resolution: detection first, then pnpm if available,
+ * then whatever binary exists. Never returns null so update/doctor flows
+ * always have a usable PM name (commands fail later with a clear error
+ * if no PM is actually installed).
+ */
+export function resolvePackageManager(projectRoot, options = {}) {
+  const detected = detectPackageManager(projectRoot, options)
+  if (detected) return detected
+
+  const available = getAvailablePackageManagers()
+  if (available.includes('pnpm')) return { name: 'pnpm', version: null, source: 'fallback' }
+  if (available.includes('npm')) return { name: 'npm', version: null, source: 'fallback' }
+  if (available.length > 0) return { name: available[0], version: null, source: 'fallback' }
+  return { name: 'pnpm', version: null, source: 'fallback (none detected)' }
+}
+
+export function installCommand(pmName, packages, { dev = false, global: isGlobal = false } = {}) {
+  const pkgs = Array.isArray(packages) ? packages.join(' ') : packages
+  const flags = [isGlobal ? '-g' : '', dev ? '-D' : ''].filter(Boolean).join(' ')
+  const flagSuffix = flags ? ` ${flags}` : ''
+  if (pmName === 'pnpm') {
+    return `${pmName} add${flagSuffix} ${pkgs}`
+  }
+  return `npm install${flagSuffix} ${pkgs}`
+}
+
+export function uninstallCommand(pmName, packages, { global: isGlobal = false } = {}) {
+  const pkgs = Array.isArray(packages) ? packages.join(' ') : packages
+  const flagSuffix = isGlobal ? ' -g' : ''
+  if (pmName === 'pnpm') {
+    return `${pmName} remove${flagSuffix} ${pkgs}`
+  }
+  return `npm uninstall${flagSuffix} ${pkgs}`
+}
+
+export function runScriptCommand(pmName, script) {
+  return `${pmName} run ${script}`
+}

package/commands/utils/PathHelper.js

@@ -1,75 +1,75 @@
-import path from 'path'
-import fs from 'fs-extra'
-import { fileURLToPath } from 'url'
-
-const sanitize = (s) => (s || '').replace(/^[/\\]+/, '')
-const dirOf = (url) => path.dirname(fileURLToPath(url))
-
-function candidates(moduleUrl) {
-  const dir = dirOf(moduleUrl)
-  return [
-    path.join(dir, '../../'),
-    path.join(dir, '../../../../')
-  ]
-}
-
-function resolveProjectRoot(moduleUrl) {
-  const initCwd = process.env.INIT_CWD
-  if (initCwd && fs.pathExistsSync(initCwd)) {
-    return initCwd
-  }
-
-  const cwd = process.cwd()
-  if (cwd && fs.pathExistsSync(cwd)) {
-    return cwd
-  }
-
-  const dirs = candidates(moduleUrl)
-  for (const root of dirs) {
-    const hasSrc = fs.pathExistsSync(path.join(root, 'src'))
-    const hasApi = fs.pathExistsSync(path.join(root, 'api'))
-    if (hasSrc || hasApi) return root
-  }
-  return dirs[1]
-}
-
-function joinProject(moduleUrl, ...segments) {
-  const root = resolveProjectRoot(moduleUrl)
-  const clean = segments.map(sanitize)
-  return path.join(root, ...clean)
-}
-
-export function getProjectRoot(moduleUrl) {
-  return resolveProjectRoot(moduleUrl)
-}
-
-export function getPath(moduleUrl, folder, ...segments) {
-  return joinProject(moduleUrl, folder, ...segments)
-}
-
-export function getSrcPath(moduleUrl, ...segments) {
-  return joinProject(moduleUrl, 'src', ...segments)
-}
-
-export function getApiPath(moduleUrl, ...segments) {
-  return joinProject(moduleUrl, 'api', ...segments)
-}
-
-export function getDistPath(moduleUrl, ...segments) {
-  return joinProject(moduleUrl, 'dist', ...segments)
-}
-
-export function getConfigPath(moduleUrl, root) {
-  if (root) return path.join(root, 'src', 'sliceConfig.json')
-  return joinProject(moduleUrl, 'src', 'sliceConfig.json')
-}
-
-export function getComponentsJsPath(moduleUrl, root) {
-  if (root) return path.join(root, 'src', 'Components', 'components.js')
-  return joinProject(moduleUrl, 'src', 'Components', 'components.js')
-}
-
-export function joinRoot(root, ...segments) {
-  const clean = segments.map(sanitize)
-  return path.join(root, ...clean)
-}
+import path from 'path'
+import fs from 'fs-extra'
+import { fileURLToPath } from 'url'
+
+const sanitize = (s) => (s || '').replace(/^[/\\]+/, '')
+const dirOf = (url) => path.dirname(fileURLToPath(url))
+
+function candidates(moduleUrl) {
+  const dir = dirOf(moduleUrl)
+  return [
+    path.join(dir, '../../'),
+    path.join(dir, '../../../../')
+  ]
+}
+
+function resolveProjectRoot(moduleUrl) {
+  const initCwd = process.env.INIT_CWD
+  if (initCwd && fs.pathExistsSync(initCwd)) {
+    return initCwd
+  }
+
+  const cwd = process.cwd()
+  if (cwd && fs.pathExistsSync(cwd)) {
+    return cwd
+  }
+
+  const dirs = candidates(moduleUrl)
+  for (const root of dirs) {
+    const hasSrc = fs.pathExistsSync(path.join(root, 'src'))
+    const hasApi = fs.pathExistsSync(path.join(root, 'api'))
+    if (hasSrc || hasApi) return root
+  }
+  return dirs[1]
+}
+
+function joinProject(moduleUrl, ...segments) {
+  const root = resolveProjectRoot(moduleUrl)
+  const clean = segments.map(sanitize)
+  return path.join(root, ...clean)
+}
+
+export function getProjectRoot(moduleUrl) {
+  return resolveProjectRoot(moduleUrl)
+}
+
+export function getPath(moduleUrl, folder, ...segments) {
+  return joinProject(moduleUrl, folder, ...segments)
+}
+
+export function getSrcPath(moduleUrl, ...segments) {
+  return joinProject(moduleUrl, 'src', ...segments)
+}
+
+export function getApiPath(moduleUrl, ...segments) {
+  return joinProject(moduleUrl, 'api', ...segments)
+}
+
+export function getDistPath(moduleUrl, ...segments) {
+  return joinProject(moduleUrl, 'dist', ...segments)
+}
+
+export function getConfigPath(moduleUrl, root) {
+  if (root) return path.join(root, 'src', 'sliceConfig.json')
+  return joinProject(moduleUrl, 'src', 'sliceConfig.json')
+}
+
+export function getComponentsJsPath(moduleUrl, root) {
+  if (root) return path.join(root, 'src', 'Components', 'components.js')
+  return joinProject(moduleUrl, 'src', 'Components', 'components.js')
+}
+
+export function joinRoot(root, ...segments) {
+  const clean = segments.map(sanitize)
+  return path.join(root, ...clean)
+}