slicejs-cli 3.5.1 → 3.6.0

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');

package/commands/utils/sliceScripts.js

@@ -0,0 +1,21 @@
+// commands/utils/sliceScripts.js
+//
+// Single source of truth for the slice:* package scripts configured by the CLI.
+// Used by post.js (the postinstall hook), the `slice postinstall` command in
+// client.js, and `slice init` — so the three can never drift apart (they did:
+// client.js was missing slice:types, and none of them had slice:build).
+export const SLICE_SCRIPTS = {
+  'slice:init': 'slice init',
+  'slice:dev': 'slice dev',
+  'slice:build': 'slice build',
+  'slice:start': 'slice start',
+  'slice:create': 'slice component create',
+  'slice:list': 'slice component list',
+  'slice:delete': 'slice component delete',
+  'slice:get': 'slice get',
+  'slice:browse': 'slice browse',
+  'slice:sync': 'slice sync',
+  'slice:version': 'slice version',
+  'slice:update': 'slice update',
+  'slice:types': 'slice types generate',
+};

package/commands/utils/updateManager.js

@@ -7,6 +7,7 @@ import ora from "ora";
 import Print from "../Print.js";
 import versionChecker from "./VersionChecker.js";
 import { getProjectRoot, getApiPath, getPath } from "../utils/PathHelper.js";
+import { resolvePackageManager, installCommand } from "../utils/PackageManager.js";
 import path from "path";
 import { fileURLToPath } from "url";
 import fs from "fs-extra";
@@ -18,28 +19,45 @@ export class UpdateManager {
         this.packagesToUpdate = [];
     }
 
+    getPackageManager() {
+        if (!this._packageManager) {
+            this._packageManager = resolvePackageManager(getProjectRoot(import.meta.url)).name;
+        }
+        return this._packageManager;
+    }
+
     async detectCliInstall() {
         try {
             const moduleDir = path.dirname(fileURLToPath(import.meta.url));
             const cliRoot = path.join(moduleDir, '../../');
             const projectRoot = getProjectRoot(import.meta.url);
+            const packageManager = this.getPackageManager();
+            const localNodeModules = path.join(projectRoot, 'node_modules');
+
+            if (cliRoot.startsWith(localNodeModules)) {
+                return { type: 'local', cliRoot, projectRoot, packageManager };
+            }
+
+            // Global pnpm installs live under PNPM_HOME — `npm config get prefix`
+            // knows nothing about them (and npm may not even exist on the machine).
+            const pnpmHome = process.env.PNPM_HOME;
+            if (pnpmHome && cliRoot.startsWith(pnpmHome)) {
+                return { type: 'global', cliRoot, projectRoot, packageManager: 'pnpm' };
+            }
+
             let globalPrefix = '';
             try {
                 const { stdout } = await execAsync('npm config get prefix');
                 globalPrefix = stdout.toString().trim();
             } catch {}
-            const localNodeModules = path.join(projectRoot, 'node_modules');
             const globalNodeModules = globalPrefix ? path.join(globalPrefix, 'node_modules') : '';
-
-            if (cliRoot.startsWith(localNodeModules)) {
-                return { type: 'local', cliRoot, projectRoot, globalPrefix };
-            }
             if (globalNodeModules && cliRoot.startsWith(globalNodeModules)) {
-                return { type: 'global', cliRoot, projectRoot, globalPrefix };
+                return { type: 'global', cliRoot, projectRoot, packageManager: 'npm' };
             }
-            return { type: 'unknown', cliRoot, projectRoot, globalPrefix };
+
+            return { type: 'unknown', cliRoot, projectRoot, packageManager };
         } catch (error) {
-            return { type: 'unknown' };
+            return { type: 'unknown', packageManager: this.getPackageManager() };
         }
     }
 
@@ -180,17 +198,12 @@ export class UpdateManager {
     async buildUpdatePlan(packages) {
         const plan = [];
         const info = await this.detectCliInstall();
+        const pm = info.packageManager || this.getPackageManager();
         for (const pkg of packages) {
-            if (pkg === 'slicejs-cli') {
-                if (info.type === 'global') {
-                    plan.push({ package: pkg, target: 'global', command: 'npm install -g slicejs-cli@latest' });
-                } else {
-                    plan.push({ package: pkg, target: 'project', command: 'npm install slicejs-cli@latest' });
-                }
-            } else if (pkg === 'slicejs-web-framework') {
-                plan.push({ package: pkg, target: 'project', command: 'npm install slicejs-web-framework@latest' });
+            if (pkg === 'slicejs-cli' && info.type === 'global') {
+                plan.push({ package: pkg, target: 'global', command: installCommand(pm, 'slicejs-cli@latest', { global: true }) });
             } else {
-                plan.push({ package: pkg, target: 'project', command: `npm install ${pkg}@latest` });
+                plan.push({ package: pkg, target: 'project', command: installCommand(pm, `${pkg}@latest`) });
             }
         }
         return plan;
@@ -201,15 +214,15 @@ export class UpdateManager {
      */
     async updatePackage(packageName) {
         try {
-            let installCmd = `npm install ${packageName}@latest`;
-            let uninstallCmd = `npm uninstall ${packageName}`;
+            const pm = this.getPackageManager();
+            let installCmd = installCommand(pm, `${packageName}@latest`);
             let options = {};
 
             if (packageName === 'slicejs-cli') {
                 const info = await this.detectCliInstall();
                 if (info.type === 'global') {
-                    installCmd = `npm install -g slicejs-cli@latest`;
-                    uninstallCmd = `npm uninstall -g slicejs-cli`;
+                    const globalPm = info.packageManager || pm;
+                    installCmd = installCommand(globalPm, 'slicejs-cli@latest', { global: true });
                 } else {
                     options.cwd = info.projectRoot || getProjectRoot(import.meta.url);
                 }
@@ -217,11 +230,9 @@ export class UpdateManager {
                 options.cwd = getProjectRoot(import.meta.url);
             }
 
-            // Try uninstall first (ignore failure)
-            try {
-                await execAsync(uninstallCmd, options);
-            } catch {}
-
+            // Install directly — npm/pnpm upgrade in place. (We used to uninstall
+            // first, which left the project without the package whenever the
+            // subsequent install failed, e.g. offline or under a release-age policy.)
             const { stdout, stderr } = await execAsync(installCmd, options);
 
             return {
@@ -284,13 +295,12 @@ export class UpdateManager {
                 return false;
             }
 
-            if (updateInfo.allCurrent) {
-                Print.success('✅ All components are up to date!');
-                return true;
-            }
-
-            if (!updateInfo.hasUpdates) {
+            if (updateInfo.allCurrent || !updateInfo.hasUpdates) {
                 Print.success('✅ All components are up to date!');
+                // --update-api works even when no package update runs.
+                if (options.updateApi) {
+                    await this.updateApiIndexIfNeeded(options);
+                }
                 return true;
             }
 
@@ -341,7 +351,7 @@ export class UpdateManager {
                 }
             } else {
                 Print.warning('Global CLI detected. It is recommended to update slicejs-cli globally to keep aligned with the framework.');
-                console.log('   Suggestion: npm install -g slicejs-cli@latest');
+                console.log(`   Suggestion: ${installCommand(cliInfo.packageManager || this.getPackageManager(), 'slicejs-cli@latest', { global: true })}`);
                 console.log('');
             }
         }
@@ -386,7 +396,7 @@ export class UpdateManager {
             }
 
             const frameworkUpdated = results.find(r => r.packageName === 'slicejs-web-framework' && r.success);
-            if (frameworkUpdated) {
+            if (frameworkUpdated || options.updateApi) {
                 await this.updateApiIndexIfNeeded(options);
             }
 
@@ -417,7 +427,16 @@ export class UpdateManager {
 
             Print.warning('⚠️ Detected changes in framework api/index.js.');
 
-            let confirmUpdate = options.yes === true;
+            // Overwriting api/index.js is opt-in: `--update-api` is the only way
+            // to auto-confirm. `-y/--yes` deliberately does NOT imply it — the
+            // project file may carry local changes, so a blanket "yes to updates"
+            // must not silently replace it.
+            let confirmUpdate = options.updateApi === true;
+            if (!confirmUpdate && options.yes === true) {
+                Print.info('Skipping api/index.js update (not updated by default).');
+                Print.info('Run "slice update --update-api" to update it (a .bak backup is created).');
+                return;
+            }
             if (!confirmUpdate) {
                 const answers = await inquirer.prompt([
                     {

package/package.json

@@ -1,11 +1,20 @@
 {
   "name": "slicejs-cli",
-  "version": "3.5.1",
+  "version": "3.6.0",
   "description": "Command client for developing web applications with Slice.js framework",
   "main": "client.js",
   "bin": {
     "slice": "./client.js"
   },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "client.js",
+    "post.js",
+    "commands",
+    "assets"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/vkneider/slicejs-cli.git"
@@ -14,6 +23,7 @@
     "test": "node --test",
     "postinstall": "node post.js",
     "slice:dev": "slice dev",
+    "slice:build": "slice build",
     "slice:start": "slice start",
     "slice:create": "slice component create",
     "slice:list": "slice component list",
@@ -38,6 +48,7 @@
   ],
   "author": "vkneider",
   "type": "module",
+  "packageManager": "pnpm@11.1.1",
   "preferGlobal": false,
   "license": "ISC",
   "dependencies": {

package/post.js

@@ -2,35 +2,27 @@ import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { getProjectRoot, getPath } from './commands/utils/PathHelper.js';
+import { SLICE_SCRIPTS } from './commands/utils/sliceScripts.js';
 
 const __filename = fileURLToPath(import.meta.url);
 
-const isGlobal = process.env.npm_config_global === 'true';
+// npm sets npm_config_global; pnpm does not — for pnpm a global install lives
+// under PNPM_HOME, so detect it by where this script is running from.
+const pnpmHome = process.env.PNPM_HOME;
+const isGlobal = process.env.npm_config_global === 'true'
+    || (pnpmHome && __filename.startsWith(pnpmHome));
 
 if (isGlobal) {
     console.log('⚠️  Global installation of slicejs-cli detected.');
     console.log('   We strongly recommend using a local installation to avoid version mismatches.');
-    console.log('   Uninstall global: npm uninstall -g slicejs-cli');
+    console.log(`   Uninstall global: ${pnpmHome ? 'pnpm remove -g slicejs-cli' : 'npm uninstall -g slicejs-cli'}`);
     process.exit(0);
 }
 
 const projectRoot = getProjectRoot(import.meta.url);
 const pkgPath = getPath(import.meta.url, 'package.json');
 
-const sliceScripts = {
-    'slice:dev': 'slice dev',
-    'slice:start': 'slice start',
-    'slice:create': 'slice component create',
-    'slice:list': 'slice component list',
-    'slice:delete': 'slice component delete',
-    'slice:init': 'slice init',
-    'slice:get': 'slice get',
-    'slice:browse': 'slice browse',
-    'slice:sync': 'slice sync',
-    'slice:version': 'slice version',
-    'slice:update': 'slice update',
-    'slice:types': 'slice types generate',
-};
+const sliceScripts = SLICE_SCRIPTS;
 
 try {
     let pkg = {};

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,29 +0,0 @@
----
-name: Bug Report
-about: Report a bug in a component or the parser
-title: ''
-labels: bug
-assignees: ''
----
-
-## Description
-A clear description of the bug.
-
-## Reproduction
-Steps to reproduce:
-1. Go to '...'
-2. Click on '...'
-3. Error: '...'
-
-## Expected behavior
-What should have happened.
-
-## Environment
-- Browser/Node version:
-- OS:
-- slice.js_visual_library version:
-
-## Screenshots / Console output
-If applicable.
-
-## Additional context

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,25 +0,0 @@
----
-name: Feature Request
-about: Suggest a new component or improvement
-title: ''
-labels: enhancement
-assignees: ''
----
-
-## Problem
-What problem does this solve? (e.g. "I need a component that...")
-
-## Proposed solution
-How should it work? Include props, behavior, and visual details if applicable.
-
-## Alternatives considered
-What other approaches have you considered?
-
-## Example usage
-```javascript
-const component = await slice.build('ComponentName', {
-  // props here
-});
-```
-
-## Additional context

package/.github/pull_request_template.md

@@ -1,22 +0,0 @@
-## Summary
-- 
-
-## Docs Scope
-- [ ] Visual library docs pages (`src/markdown/` and generated outputs)
-- [ ] Parser logic (`parser/`)
-- [ ] Routes/index sync (`documentationRoutes.generated.js`, `docsIndex.js`, `components.js`)
-
-## Verification
-- [ ] `npm run docs:lint-md`
-- [ ] `npm run docs:generate`
-- [ ] `node --test parser/tests/index.test.js`
-
-## Screenshots / UI Notes
-- 
-
-## Breaking Changes
-- [ ] None
-- [ ] Yes (describe below)
-
-## Additional Context
-- 

package/.github/workflows/ci.yml

@@ -1,43 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [master, main]
-  pull_request:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: pnpm/action-setup@v4
-        with:
-          version: 11
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Install Playwright browser
-        run: pnpm exec playwright install --with-deps chromium
-
-      # Serialized to avoid resource contention between the build-heavy
-      # integration tests under parallel runners.
-      - name: Unit & integration tests
-        run: node --test --test-concurrency=1
-
-      - name: Browser E2E tests
-        run: pnpm exec playwright test
-
-      - uses: actions/upload-artifact@v4
-        if: ${{ !cancelled() }}
-        with:
-          name: playwright-report
-          path: playwright-report/
-          retention-days: 7