slicejs-cli 3.5.1 → 3.6.0

package/README.md

@@ -28,9 +28,9 @@ This repository contains the Slice.js CLI (`slicejs-cli`), the command-line tool
    cd slicejs-cli
    ```
 
-2. **Install dependencies**
+2. **Install dependencies** (the repo pins pnpm via the `packageManager` field)
    ```bash
-   npm install
+   pnpm install --frozen-lockfile
    ```
 
 3. **Test changes locally**
@@ -50,18 +50,24 @@ This repository contains the Slice.js CLI (`slicejs-cli`), the command-line tool
 
 ## Installation (for users)
 
-### Local (Recommended)
+For a **new project** you don't install anything manually — `slice init` (see Quick
+start below) installs the CLI locally in the project it creates.
+
+### Local in an existing project (Recommended)
 
 ```bash
-npm install slicejs-cli --save-dev
+npm install slicejs-cli --save-dev    # or: pnpm add -D slicejs-cli
 ```
 
-### Global (Not recommended)
+### Global launcher (optional)
 
 ```bash
-npm install -g slicejs-cli
+npm install -g slicejs-cli            # or: pnpm add -g slicejs-cli
 ```
 
+The launcher delegates to the nearest project-local `node_modules/slicejs-cli`,
+so each project keeps its pinned CLI version.
+
 ## Main commands
 
 | Command | Description |
@@ -106,21 +112,34 @@ npx slicejs-cli postinstall
 
 ## Quick start
 
+`slice init` creates the project folder itself — no `mkdir` or `npm init` needed.
+Everything (package.json, node_modules, lockfile, src/, api/) lives inside the new folder.
+
 ```bash
-# 1. Create project
-mkdir my-project && cd my-project
-npm init -y
+# With npm
+npx slicejs-cli init
+cd my-app
+npm run dev
+```
 
-# 2. Install CLI
-npm install slicejs-cli --save-dev
+```bash
+# With pnpm
+pnpm dlx slicejs-cli init
+cd my-app
+pnpm run dev
+```
 
-# 3. Initialize
-npx slicejs-cli init
+Non-interactive (for scripts/CI):
 
-# 4. Development
-npx slicejs-cli dev
+```bash
+npx slicejs-cli init -y my-app --pm pnpm
 ```
 
+init pins the chosen package manager in the `packageManager` field, installs
+`slicejs-web-framework` as a dependency and `slicejs-cli` as a devDependency of
+the new project. Versions are never hard-pinned at install time, so hardened pnpm
+setups (`minimumReleaseAge` quarantine, `ignore-scripts`) work out of the box.
+
 ## Tests
 
 The CLI uses Node.js native test runner:

package/client.js

@@ -27,6 +27,13 @@ import {
   resolveLocalCliCandidate,
   shouldDelegateToLocalCli
 } from './commands/utils/LocalCliDelegation.js';
+import {
+  detectPackageManager,
+  getAvailablePackageManagers,
+  isPackageManagerAvailable,
+  SUPPORTED_PACKAGE_MANAGERS
+} from './commands/utils/PackageManager.js';
+import { SLICE_SCRIPTS } from './commands/utils/sliceScripts.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -96,6 +103,7 @@ sliceClient
   .command("init")
   .description("Initialize a new Slice.js project")
   .option("-y, --yes [name]", "Skip prompts and initialize with project name")
+  .option("--pm <packageManager>", "Package manager to use (npm, pnpm or yarn). Auto-detected when omitted")
   .action(async (options) => {
     let projectName = 'my-slice-app';
     if (options.yes) {
@@ -123,16 +131,62 @@ sliceClient
       projectName = answers.projectName;
     }
 
+    // Resolve the package manager: --pm flag → detection → interactive prompt.
+    // Detection here has no project root yet (the folder is new), so it relies on
+    // npm_config_user_agent (npx / pnpm dlx / PM scripts) or a single available binary.
+    let packageManager = options.pm;
+    if (packageManager && !SUPPORTED_PACKAGE_MANAGERS.includes(packageManager)) {
+      Print.error(`Unsupported package manager "${packageManager}". Use one of: ${SUPPORTED_PACKAGE_MANAGERS.join(', ')}`);
+      return;
+    }
+    if (packageManager && !isPackageManagerAvailable(packageManager)) {
+      Print.error(`Package manager "${packageManager}" is not available on this system`);
+      return;
+    }
+    if (!packageManager) {
+      const detected = detectPackageManager(null);
+      if (detected) {
+        packageManager = detected.name;
+      } else if (!options.yes) {
+        const available = getAvailablePackageManagers();
+        if (available.length === 0) {
+          Print.error('No package manager found (npm, pnpm or yarn). Install one and retry.');
+          return;
+        }
+        const { pm } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'pm',
+            message: 'Which package manager do you want to use?',
+            choices: available,
+            default: available.includes('pnpm') ? 'pnpm' : available[0]
+          }
+        ]);
+        packageManager = pm;
+      } else {
+        const available = getAvailablePackageManagers();
+        packageManager = available.includes('npm') ? 'npm' : available[0];
+        if (!packageManager) {
+          Print.error('No package manager found (npm, pnpm or yarn). Install one and retry.');
+          return;
+        }
+      }
+    }
+
     const projectDir = path.resolve(projectName);
 
     if (fs.existsSync(projectDir)) {
       const contents = fs.readdirSync(projectDir);
       if (contents.length > 0) {
+        if (options.yes) {
+          Print.error(`Directory "${projectName}" already exists and is not empty. Aborting.`);
+          return;
+        }
         const { overwrite } = await inquirer.prompt([
           {
             type: 'confirm',
             name: 'overwrite',
-            message: `Directory "${answers.projectName}" already exists and is not empty. Continue?`,
+            message: `Directory "${projectName}" already exists and is not empty. Continue?`,
             default: false
           }
         ]);
@@ -148,9 +202,8 @@ sliceClient
     process.chdir(projectDir);
     process.env.INIT_CWD = projectDir;
 
-    await runWithVersionCheck(() => {
-      initializeProject();
-      return Promise.resolve();
+    await runWithVersionCheck(async () => {
+      await initializeProject({ packageManager });
     });
   });
 
@@ -353,7 +406,7 @@ componentCommand
           category = categoryAnswer.category;
         }
 
-        const config = loadConfig();
+        const config = sharedLoadConfigSync(import.meta.url);
         if (!config) {
           Print.error("Could not load configuration");
           return;
@@ -550,6 +603,7 @@ sliceClient
   .option("-y, --yes", "Skip confirmation and update all packages automatically")
   .option("--cli", "Update only the Slice.js CLI")
   .option("-f, --framework", "Update only the Slice.js Framework")
+  .option("--update-api", "Also overwrite api/index.js with the framework version (never done by default; creates a .bak backup)")
   .action(async (options) => {
     await updateManager.checkAndPromptUpdates(options);
   });
@@ -570,30 +624,23 @@ sliceClient
   .command("postinstall")
   .description("Configure npm scripts in package.json (alternative to postinstall for --ignore-scripts users)")
   .action(() => {
-    const isGlobal = process.env.npm_config_global === 'true';
+    // npm sets npm_config_global; pnpm global installs are detected via PNPM_HOME.
+    const pnpmHome = process.env.PNPM_HOME;
+    const cliEntryPath = fileURLToPath(import.meta.url);
+    const isGlobal = process.env.npm_config_global === 'true'
+      || (pnpmHome && cliEntryPath.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'}`);
       return;
     }
 
     const projectRoot = getProjectRoot(import.meta.url);
     const pkgPath = path.join(projectRoot, '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',
-    };
+    // Shared with post.js and slice init — see commands/utils/sliceScripts.js
+    const sliceScripts = SLICE_SCRIPTS;
 
     try {
       let pkg = {};

package/commands/doctor/doctor.js

@@ -8,6 +8,7 @@ import inquirer from 'inquirer';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { getProjectRoot, getSrcPath, getApiPath, getConfigPath, getPath } from '../utils/PathHelper.js';
+import { resolvePackageManager, installCommand } from '../utils/PackageManager.js';
 import updateManager from '../utils/updateManager.js';
 
 /**
@@ -142,6 +143,69 @@ async function checkPort() {
     });
 }
 
+/**
+ * Checks the package manager setup: mixed lockfiles, packageManager field
+ * consistency, and a project-local CLI install (required for local delegation).
+ * Exported for tests.
+ */
+export async function checkPackageManagerSetup(projectRoot = getProjectRoot(import.meta.url)) {
+    const issues = [];
+    const suggestions = [];
+
+    const LOCKFILE_PM = {
+        'package-lock.json': 'npm',
+        'pnpm-lock.yaml': 'pnpm',
+        'yarn.lock': 'yarn'
+    };
+    const lockfiles = [];
+    for (const lockfile of Object.keys(LOCKFILE_PM)) {
+        if (await fs.pathExists(path.join(projectRoot, lockfile))) {
+            lockfiles.push(lockfile);
+        }
+    }
+
+    let pkg = null;
+    const pkgPath = path.join(projectRoot, 'package.json');
+    if (await fs.pathExists(pkgPath)) {
+        try { pkg = await fs.readJson(pkgPath); } catch { /* reported by Dependencies check */ }
+    }
+    const pmField = typeof pkg?.packageManager === 'string' ? pkg.packageManager.split('@')[0] : null;
+    const pm = resolvePackageManager(projectRoot).name;
+
+    if (lockfiles.length > 1) {
+        issues.push(`Mixed lockfiles found: ${lockfiles.join(', ')}`);
+        const keep = pmField || pm;
+        const keepLockfile = Object.entries(LOCKFILE_PM).find(([, name]) => name === keep)?.[0];
+        suggestions.push(`Keep only ${keepLockfile ?? 'the lockfile of your package manager'} and delete the rest`);
+    }
+
+    if (pkg && !pmField) {
+        issues.push('No "packageManager" field in package.json');
+        suggestions.push(`Pin it (e.g. "packageManager": "${pm}@<version>") so every tool resolves the same package manager`);
+    } else if (pmField && lockfiles.length === 1 && LOCKFILE_PM[lockfiles[0]] !== pmField) {
+        issues.push(`packageManager is "${pmField}" but the lockfile is ${lockfiles[0]}`);
+        suggestions.push(`Reinstall with ${pmField} (or update the packageManager field) so they agree`);
+    }
+
+    const localCliPath = path.join(projectRoot, 'node_modules', 'slicejs-cli', 'package.json');
+    if (pkg && !(await fs.pathExists(localCliPath))) {
+        issues.push('slicejs-cli is not installed locally');
+        suggestions.push(`Run "${installCommand(pm, 'slicejs-cli', { dev: true })}" so the launcher delegates to a version pinned per project`);
+    }
+
+    if (issues.length === 0) {
+        return {
+            pass: true,
+            message: `Package manager setup is consistent (${pmField || pm})`
+        };
+    }
+    return {
+        warn: true,
+        message: issues.join(' | '),
+        suggestion: suggestions.join(' | ')
+    };
+}
+
 /**
  * Checks dependencies in package.json
  */
@@ -176,8 +240,8 @@ async function checkDependencies() {
                 warn: true,
                 message: `Missing dependencies: ${missing.join(', ')}`,
                 suggestion: missing.includes('slicejs-web-framework')
-                    ? 'Run "npm install slicejs-web-framework@latest" in your project'
-                    : 'Run "npm install -D slicejs-cli@latest" in your project',
+                    ? `Run "${installCommand(resolvePackageManager(getProjectRoot(import.meta.url)).name, 'slicejs-web-framework@latest')}" in your project`
+                    : `Run "${installCommand(resolvePackageManager(getProjectRoot(import.meta.url)).name, 'slicejs-cli@latest', { dev: true })}" in your project`,
                 missing
             };
         }
@@ -278,6 +342,7 @@ export default async function runDiagnostics() {
         { name: 'Project Structure', fn: checkDirectoryStructure },
         { name: 'Configuration', fn: checkConfig },
         { name: 'Port Availability', fn: checkPort },
+        { name: 'Package Manager', fn: checkPackageManagerSetup },
         { name: 'Dependencies', fn: checkDependencies },
         { name: 'Components', fn: checkComponents }
     ];
@@ -340,9 +405,10 @@ export default async function runDiagnostics() {
             }
         ]);
         if (confirmInstall) {
+            const pm = resolvePackageManager(projectRoot).name;
             for (const pkg of depsResult.missing) {
                 try {
-                    const cmd = 'npm install slicejs-web-framework@latest';
+                    const cmd = installCommand(pm, `${pkg}@latest`);
                     Print.info(`Installing ${pkg}...`);
                     await execAsync(cmd, { cwd: projectRoot });
                     Print.success(`${pkg} installed`);

package/commands/getComponent/getComponent.js

@@ -50,6 +50,10 @@ class ComponentRegistry {
     this.componentsRegistry = null;
     this.config = null;
     this._configPromise = null;
+    // Serializes read-modify-write cycles on components.js: installs run
+    // concurrently (runConcurrent), and parallel writers corrupt the file
+    // (partial reads) or silently drop registrations (lost updates).
+    this._registryLock = Promise.resolve();
   }
 
   async _ensureConfig() {
@@ -249,31 +253,35 @@ filterOfficialComponents(allComponents) {
   }
 
   async updateLocalRegistrySafe(componentName, category) {
+    // Queue behind any in-flight registry update; keep the chain alive even
+    // when an update throws so later updates still run.
+    const run = this._registryLock.then(() => this._updateLocalRegistry(componentName, category));
+    this._registryLock = run.catch(() => {});
+    return run;
+  }
+
+  async _updateLocalRegistry(componentName, category) {
     const componentsPath = getComponentsJsPath(import.meta.url);
-    try {
-      if (!await fs.pathExists(componentsPath)) {
-        const dir = path.dirname(componentsPath);
-        await fs.ensureDir(dir);
-        const initial = `const components = {};\n\nexport default components;\n`;
-        await fs.writeFile(componentsPath, initial, 'utf8');
-      }
-      const content = await fs.readFile(componentsPath, 'utf8');
-      const match = content.match(/const components = ({[\s\S]*?});/);
-      if (!match) throw new Error('Invalid components.js format in local project');
-      const componentsObj = JSON.parse(match[1]);
-      if (!componentsObj[componentName]) {
-        componentsObj[componentName] = category;
-        const sorted = Object.keys(componentsObj)
-          .sort()
-          .reduce((obj, key) => { obj[key] = componentsObj[key]; return obj; }, {});
-        const newContent = `const components = ${JSON.stringify(sorted, null, 2)};\n\nexport default components;\n`;
-        await fs.writeFile(componentsPath, newContent, 'utf8');
-        Print.registryUpdate(`Registered ${componentName} in local components.js`);
-      } else {
-        Print.info(`${componentName} already exists in local registry`);
-      }
-    } catch (error) {
-      throw error;
+    if (!await fs.pathExists(componentsPath)) {
+      const dir = path.dirname(componentsPath);
+      await fs.ensureDir(dir);
+      const initial = `const components = {};\n\nexport default components;\n`;
+      await fs.writeFile(componentsPath, initial, 'utf8');
+    }
+    const content = await fs.readFile(componentsPath, 'utf8');
+    const match = content.match(/const components = ({[\s\S]*?});/);
+    if (!match) throw new Error('Invalid components.js format in local project');
+    const componentsObj = JSON.parse(match[1]);
+    if (!componentsObj[componentName]) {
+      componentsObj[componentName] = category;
+      const sorted = Object.keys(componentsObj)
+        .sort()
+        .reduce((obj, key) => { obj[key] = componentsObj[key]; return obj; }, {});
+      const newContent = `const components = ${JSON.stringify(sorted, null, 2)};\n\nexport default components;\n`;
+      await fs.writeFile(componentsPath, newContent, 'utf8');
+      Print.registryUpdate(`Registered ${componentName} in local components.js`);
+    } else {
+      Print.info(`${componentName} already exists in local registry`);
     }
   }
 
@@ -339,7 +347,7 @@ filterOfficialComponents(allComponents) {
       await this.updateLocalRegistrySafe(componentName, category);
 
       Print.success(`${componentName} installed successfully from official repository!`);
-      console.log(`📁 Location: ${folderSuffix}/${categoryPath}/${componentName}/`);
+      console.log(`📁 Location: ${[folderSuffix, categoryPath, componentName].join('/').replace(/\/+/g, '/')}/`);
       console.log(`📄 Files: ${downloadedFiles.join(', ')}`);
 
       return true;

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