slicejs-web-framework 3.4.4 → 3.5.1

package/slicejs-cli/commands/utils/PackageManager.js

@@ -1,148 +0,0 @@
-// 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/slicejs-cli/commands/utils/PathHelper.js

@@ -1,75 +0,0 @@
-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)
-}

package/slicejs-cli/commands/utils/VersionChecker.js

@@ -1,169 +0,0 @@
-// commands/utils/VersionChecker.js
-
-import fs from "fs-extra";
-import path from "path";
-import { fileURLToPath } from "url";
-import Print from "../Print.js";
-import { getProjectRoot, getPath } from "../utils/PathHelper.js";
-import { resolvePackageManager } from "../utils/PackageManager.js";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-class VersionChecker {
-  constructor() {
-    this.currentCliVersion = null;
-    this.currentFrameworkVersion = null;
-    this.latestCliVersion = null;
-    this.latestFrameworkVersion = null;
-  }
-
-  async getCurrentVersions() {
-    try {
-      // Get CLI version
-      const cliPackagePath = path.join(__dirname, '../../package.json');
-      const cliPackage = await fs.readJson(cliPackagePath);
-      this.currentCliVersion = cliPackage.version;
-
-      // Get Framework version from project node_modules
-      const projectRoot = getProjectRoot(import.meta.url);
-      const frameworkPackagePath = getPath(import.meta.url, 'node_modules', 'slicejs-web-framework', 'package.json');
-      if (await fs.pathExists(frameworkPackagePath)) {
-        const frameworkPackage = await fs.readJson(frameworkPackagePath);
-        this.currentFrameworkVersion = frameworkPackage.version;
-      }
-
-      // Get Project's CLI version
-      const projectPackagePath = getPath(import.meta.url, 'package.json');
-      if (await fs.pathExists(projectPackagePath)) {
-        const projectPackage = await fs.readJson(projectPackagePath);
-        if (projectPackage.dependencies && projectPackage.dependencies['slicejs-cli']) {
-          // This could be different from the currently running CLI version
-        }
-      }
-
-      return {
-        cli: this.currentCliVersion,
-        framework: this.currentFrameworkVersion
-      };
-    } catch (error) {
-      return null;
-    }
-  }
-
-  async getLatestVersions() {
-    try {
-      // Check CLI version
-      const cliResponse = await fetch('https://registry.npmjs.org/slicejs-cli/latest', {
-        headers: { 'Accept': 'application/json' }
-      });
-      
-      if (cliResponse.ok) {
-        const cliData = await cliResponse.json();
-        this.latestCliVersion = cliData.version;
-      }
-
-      // Check Framework version  
-      const frameworkResponse = await fetch('https://registry.npmjs.org/slicejs-web-framework/latest', {
-        headers: { 'Accept': 'application/json' }
-      });
-      
-      if (frameworkResponse.ok) {
-        const frameworkData = await frameworkResponse.json();
-        this.latestFrameworkVersion = frameworkData.version;
-      }
-
-      return {
-        cli: this.latestCliVersion,
-        framework: this.latestFrameworkVersion
-      };
-    } catch (error) {
-      // Silent fail - don't interrupt commands for version check failures
-      return null;
-    }
-  }
-
-  compareVersions(current, latest) {
-    if (!current || !latest) return null;
-    
-    const currentParts = current.split('.').map(Number);
-    const latestParts = latest.split('.').map(Number);
-    
-    for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
-      const currentPart = currentParts[i] || 0;
-      const latestPart = latestParts[i] || 0;
-      
-      if (latestPart > currentPart) return 'outdated';
-      if (currentPart > latestPart) return 'newer';
-    }
-    
-    return 'current';
-  }
-
-  async checkForUpdates(silent = false) {
-    try {
-      const current = await this.getCurrentVersions();
-      if (!current) return;
-
-      const latest = await this.getLatestVersions();
-      if (!latest) return;
-
-      const cliStatus = this.compareVersions(current.cli, latest.cli);
-      const frameworkStatus = this.compareVersions(current.framework, latest.framework);
-
-      if (!silent && (cliStatus === 'outdated' || frameworkStatus === 'outdated')) {
-        const pm = resolvePackageManager(getProjectRoot(import.meta.url)).name;
-        console.log(''); // Line break
-        Print.warning('📦 Available Updates:');
-
-        if (cliStatus === 'outdated') {
-          console.log(`   🔧 CLI: ${current.cli} → ${latest.cli}`);
-          console.log(`       ${pm} update slicejs-cli`);
-        }
-
-        if (frameworkStatus === 'outdated') {
-          console.log(`   ⚡ Framework: ${current.framework} → ${latest.framework}`);
-          console.log(`       ${pm} update slicejs-web-framework`);
-        }
-        
-        console.log('   📚 Changelog: https://github.com/VKneider/slice.js/releases');
-        console.log(''); // Line break
-      }
-
-      return {
-        cli: { current: current.cli, latest: latest.cli, status: cliStatus },
-        framework: { current: current.framework, latest: latest.framework, status: frameworkStatus }
-      };
-
-    } catch (error) {
-      // Silent fail - don't interrupt commands
-      return null;
-    }
-  }
-
-  async showVersionInfo() {
-    const current = await this.getCurrentVersions();
-    const latest = await this.getLatestVersions();
-    
-    console.log('\n📋 Version Information:');
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-    
-    if (current?.cli) {
-      const cliStatus = this.compareVersions(current.cli, latest?.cli);
-      const statusIcon = cliStatus === 'current' ? '✅' : cliStatus === 'outdated' ? '🔄' : '🆕';
-      console.log(`${statusIcon} CLI: v${current.cli}${latest?.cli && latest.cli !== current.cli ? ` (latest: v${latest.cli})` : ''}`);
-    }
-    
-    if (current?.framework) {
-      const frameworkStatus = this.compareVersions(current.framework, latest?.framework);
-      const statusIcon = frameworkStatus === 'current' ? '✅' : frameworkStatus === 'outdated' ? '🔄' : '🆕';
-      console.log(`${statusIcon} Framework: v${current.framework}${latest?.framework && latest.framework !== current.framework ? ` (latest: v${latest.framework})` : ''}`);
-    }
-    
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-  }
-}
-
-// Singleton instance
-const versionChecker = new VersionChecker();
-
-export default versionChecker;