slicejs-cli 3.5.0 → 3.6.0

package/commands/init/init.js

@@ -5,10 +5,62 @@ import ora from 'ora';
 import Print from '../Print.js';
 import { getProjectRoot, getApiPath, getSrcPath, getPath } from '../utils/PathHelper.js';
 import { execSync } from 'child_process';
+import {
+    resolvePackageManager,
+    getPackageManagerVersion,
+    installCommand
+} from '../utils/PackageManager.js';
+import { SLICE_SCRIPTS } from '../utils/sliceScripts.js';
 
 // Import ComponentRegistry class from getComponent
 import { ComponentRegistry } from '../getComponent/getComponent.js';
 
+// Fetch the latest published version straight from the npm registry. This is
+// informational only (we never pin installs to it): it avoids depending on
+// `npm view` (absent on pnpm-only machines) and plays nice with pnpm's
+// minimumReleaseAge quarantine, which may legitimately resolve an older version.
+async function fetchLatestVersion(packageName) {
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+            headers: { 'Accept': 'application/json' }
+        });
+        if (!response.ok) return null;
+        const data = await response.json();
+        return data.version || null;
+    } catch {
+        return null;
+    }
+}
+
+// Create the project manifest BEFORE any install runs. Without a package.json in
+// the project folder, npm/pnpm walk up the directory tree looking for the nearest
+// manifest and anchor node_modules (and the dependency entry) OUTSIDE the project.
+// Exported for tests (init-project-isolation.test.js).
+export async function ensureProjectManifest(projectRoot, packageManager) {
+    const pkgPath = path.join(projectRoot, 'package.json');
+    if (await fs.pathExists(pkgPath)) return pkgPath;
+
+    const pkg = {
+        name: path.basename(projectRoot),
+        version: '1.0.0',
+        description: 'Slice.js project',
+        main: 'api/index.js',
+        type: 'module',
+        engines: { node: '>=20.0.0' },
+        scripts: {}
+    };
+
+    // Persist the chosen package manager (corepack convention) so every later
+    // command — slice update, slice doctor — detects it deterministically.
+    const pmVersion = getPackageManagerVersion(packageManager);
+    if (pmVersion) {
+        pkg.packageManager = `${packageManager}@${pmVersion}`;
+    }
+
+    await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2), 'utf8');
+    return pkgPath;
+}
+
 // Visual components used by the App Shell + MultiRoute starter project.
 // We install only these on init; newcomers add more on demand with `slice get <Name>`.
 const STARTER_VISUAL_COMPONENTS = [
@@ -30,32 +82,52 @@ const STARTER_SERVICE_COMPONENTS = [
    'LocalStorageManager'
 ];
 
-export default async function initializeProject(projectType) {
+export default async function initializeProject(options = {}) {
     try {
         const projectRoot = getProjectRoot(import.meta.url);
         const destinationApi = getApiPath(import.meta.url);
         const destinationSrc = getSrcPath(import.meta.url);
 
+        // Resolve the package manager chosen in `slice init` (or detect it when
+        // initializeProject is invoked directly, e.g. inside an existing folder).
+        const packageManager = options.packageManager
+            || resolvePackageManager(projectRoot).name;
+
+        // 0. CREATE PROJECT MANIFEST FIRST — must exist before any install so the
+        // package manager anchors node_modules inside the project folder.
+        await ensureProjectManifest(projectRoot, packageManager);
+
         const fwSpinner = ora('Ensuring latest Slice framework...').start();
         let latestVersion = null;
+        let installedVersion = null;
         let sliceBaseDir;
         try {
-            const latest = execSync('npm view slicejs-web-framework version', { cwd: projectRoot }).toString().trim();
-            latestVersion = latest;
+            latestVersion = await fetchLatestVersion('slicejs-web-framework');
             const installedPkgPath = getPath(import.meta.url, 'node_modules', 'slicejs-web-framework', 'package.json');
             let installed = null;
             if (await fs.pathExists(installedPkgPath)) {
                 const pkg = await fs.readJson(installedPkgPath);
                 installed = pkg.version;
             }
-            if (installed !== latest) {
-                execSync(`npm install slicejs-web-framework@${latest} --save`, { cwd: projectRoot, stdio: 'inherit' });
+            if (!installed || (latestVersion && installed !== latestVersion)) {
+                // Install WITHOUT pinning an exact version: the package manager
+                // resolves it under its own policies (e.g. pnpm minimumReleaseAge
+                // quarantines versions younger than the configured age — pinning
+                // the registry's freshest version would make resolution fail).
+                execSync(installCommand(packageManager, 'slicejs-web-framework'), { cwd: projectRoot, stdio: 'inherit' });
+            }
+            if (await fs.pathExists(installedPkgPath)) {
+                const pkg = await fs.readJson(installedPkgPath);
+                installedVersion = pkg.version;
             }
             sliceBaseDir = getPath(import.meta.url, 'node_modules', 'slicejs-web-framework');
-            fwSpinner.succeed(`slicejs-web-framework@${latest} ready`);
+            fwSpinner.succeed(`slicejs-web-framework@${installedVersion || 'unknown'} ready`);
+            if (latestVersion && installedVersion && installedVersion !== latestVersion) {
+                Print.info(`Latest published is ${latestVersion}; your package manager resolved ${installedVersion} (release-age policy or cached registry).`);
+            }
         } catch (err) {
             // Fallback uses __dirname-style path because it looks for a local development copy,
-            // not a project-relative path — npm install failed, so we fall back to monorepo sibling.
+            // not a project-relative path — the install failed, so we fall back to monorepo sibling.
             const fallback = path.join(path.dirname(fileURLToPath(import.meta.url)), '../../../slicejs-web-framework');
             if (await fs.pathExists(fallback)) {
                 sliceBaseDir = fallback;
@@ -67,6 +139,21 @@ export default async function initializeProject(projectType) {
             }
         }
 
+        // 0b. INSTALL THE CLI LOCALLY (devDependency) so the generated scripts
+        // (`npm run dev` → `slice dev`) resolve via local delegation to a version
+        // pinned per project, as the docs recommend.
+        const cliSpinner = ora('Installing slicejs-cli as devDependency...').start();
+        try {
+            const cliPkgPath = getPath(import.meta.url, 'node_modules', 'slicejs-cli', 'package.json');
+            if (!(await fs.pathExists(cliPkgPath))) {
+                execSync(installCommand(packageManager, 'slicejs-cli', { dev: true }), { cwd: projectRoot, stdio: 'inherit' });
+            }
+            cliSpinner.succeed('slicejs-cli installed locally');
+        } catch (err) {
+            cliSpinner.warn('Could not install slicejs-cli locally — scripts will use the global CLI');
+            Print.info(`You can add it later with: ${installCommand(packageManager, 'slicejs-cli', { dev: true })}`);
+        }
+
         // These derive from sliceBaseDir (which comes from npm install or fallback),
         // so they're already dynamic — no PathHelper needed.
         const apiDir = path.join(sliceBaseDir, 'api');
@@ -245,6 +332,7 @@ export default async function initializeProject(projectType) {
 
             // Comandos principales
             pkg.scripts['dev'] = 'slice dev';
+            pkg.scripts['build'] = 'slice build';
             pkg.scripts['start'] = 'slice start';
 
             // Component management
@@ -257,39 +345,28 @@ export default async function initializeProject(projectType) {
             pkg.scripts['browse'] = 'slice browse';
             pkg.scripts['sync'] = 'slice sync';
 
-            // Utilidades
-            pkg.scripts['slice:version'] = 'slice version';
-            pkg.scripts['slice:update'] = 'slice update';
-            pkg.scripts['slice:types'] = 'slice types generate';
-
-            // Legacy (compatibility)
-            pkg.scripts['slice:init'] = 'slice init';
-            pkg.scripts['slice:start'] = 'slice start';
-            pkg.scripts['slice:dev'] = 'slice dev';
-            pkg.scripts['slice:create'] = 'slice component create';
-            pkg.scripts['slice:list'] = 'slice component list';
-            pkg.scripts['slice:delete'] = 'slice component delete';
-            pkg.scripts['slice:get'] = 'slice get';
-            pkg.scripts['slice:browse'] = 'slice browse';
-            pkg.scripts['slice:sync'] = 'slice sync';
+            // slice:* namespaced set — shared with post.js and `slice postinstall`
+            // (commands/utils/sliceScripts.js) so the three never drift apart.
+            Object.assign(pkg.scripts, SLICE_SCRIPTS);
             pkg.scripts['run'] = 'slice dev';
 
             // Module configuration
             pkg.type = 'module';
             pkg.engines = pkg.engines || { node: '>=20.0.0' };
 
-            // Ensure framework dependency is present
+            // Ensure framework dependency is present (the install above normally
+            // already wrote it; this is a fallback for the monorepo-sibling path).
             if (!pkg.dependencies['slicejs-web-framework']) {
-                pkg.dependencies['slicejs-web-framework'] = latestVersion ? latestVersion : 'latest';
+                pkg.dependencies['slicejs-web-framework'] = installedVersion ? `^${installedVersion}` : 'latest';
             }
 
             await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2), 'utf8');
-            pkgSpinner.succeed('npm scripts configured successfully');
+            pkgSpinner.succeed('Package scripts configured successfully');
 
             Print.title('New recommended commands:');
-            console.log('  npm run dev            - Start development server');
-            console.log('  npm run get            - Install components');
-            console.log('  npm run browse         - Browse components');
+            console.log(`  ${packageManager} run dev            - Start development server`);
+            console.log(`  ${packageManager} run get            - Install components`);
+            console.log(`  ${packageManager} run browse         - Browse components`);
         } catch (error) {
         pkgSpinner.fail('Failed to configure npm scripts');
         Print.error(error.message);
@@ -300,6 +377,7 @@ export default async function initializeProject(projectType) {
         Print.newLine();
         Print.title('Next steps:');
         console.log(`  cd ${projectName}`);
+        console.log(`  ${packageManager} run dev     - Start development server`);
         console.log('  slice browse          - View available components');
         console.log('  slice get Button      - Install specific components');
         console.log('  slice sync            - Update all components to latest versions');

package/commands/utils/PackageManager.js

@@ -0,0 +1,148 @@
+// commands/utils/PackageManager.js
+//
+// Package manager detection and command building (npm / pnpm / yarn).
+// 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 npm (non-interactive).
+
+import fs from 'fs-extra'
+import path from 'path'
+import { spawnSync } from 'node:child_process'
+
+export const SUPPORTED_PACKAGE_MANAGERS = ['npm', 'pnpm', 'yarn']
+
+const LOCKFILES = {
+  'pnpm-lock.yaml': 'pnpm',
+  'package-lock.json': 'npm',
+  'yarn.lock': 'yarn'
+}
+
+export function parseUserAgent(userAgent = process.env.npm_config_user_agent) {
+  if (!userAgent) return null
+  const match = userAgent.match(/^(npm|pnpm|yarn)\/(\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|yarn)@(\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 npm 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('npm')) return { name: 'npm', version: null, source: 'fallback' }
+  if (available.length > 0) return { name: available[0], version: null, source: 'fallback' }
+  return { name: 'npm', 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' || pmName === 'yarn') {
+    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' || pmName === 'yarn') {
+    return `${pmName} remove${flagSuffix} ${pkgs}`
+  }
+  return `npm uninstall${flagSuffix} ${pkgs}`
+}
+
+export function runScriptCommand(pmName, script) {
+  return `${pmName} run ${script}`
+}

package/commands/utils/VersionChecker.js

@@ -5,6 +5,7 @@ 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));
 
@@ -110,17 +111,18 @@ class VersionChecker {
       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(`       npm update slicejs-cli`);
+          console.log(`       ${pm} update slicejs-cli`);
         }
-        
+
         if (frameworkStatus === 'outdated') {
           console.log(`   ⚡ Framework: ${current.framework} → ${latest.framework}`);
-          console.log(`       npm update slicejs-web-framework`);
+          console.log(`       ${pm} update slicejs-web-framework`);
         }
         
         console.log('   📚 Changelog: https://github.com/VKneider/slice.js/releases');