slicejs-cli 3.0.0 → 3.0.2

package/README.md

@@ -45,6 +45,29 @@ npm run dev
 npm run slice -- get Button
 ```
 
+4. Use `slice` directly when the launcher command is available on your system
+   (commonly after a global install that puts `slice` in your PATH).
+   The launcher delegates to your nearest project-local `node_modules/slicejs-cli`
+   so project-pinned behavior is used from the project root and subdirectories.
+
+```bash
+slice dev
+slice build
+slice version
+```
+
+If `slice` is not available in your shell, use:
+
+```bash
+npx slicejs-cli dev
+```
+
+You can disable launcher delegation for a command when needed:
+
+```bash
+SLICE_NO_LOCAL_DELEGATION=1 slice version
+```
+
 ### Global (Not Recommended)
 
 Global installations can lead to version mismatches and "works on my machine" issues.
@@ -55,7 +78,10 @@ npm install -g slicejs-cli
 
 ## Usage
 
-After installation, you can use the `slice` command directly:
+After installation, prefer your project-local CLI. When the `slice` launcher command is
+available, it automatically delegates to the nearest local `slicejs-cli` install.
+
+Use the `slice` command directly:
 
 ```bash
 slice [command] [options]
@@ -67,6 +93,8 @@ Or with npx (without global install):
 npx slicejs-cli [command]
 ```
 
+Use `npx slicejs-cli [command]` as a fallback when the `slice` launcher command is unavailable.
+
 ## Essential Commands
 
 ### Initialize a project
@@ -154,7 +182,7 @@ slice sync
 ```bash
 # Version info
 slice version
-slice -v
+slice v
 
 # Updates (CLI and Framework)
 slice update              # Check and prompt to update
@@ -325,16 +353,16 @@ slice init
 ### Command not found
 
 ```bash
-# Use npx if not installed globally
+# If the launcher command is unavailable, run the local CLI via npx
 npx slicejs-cli dev
 
-# Or install globally
+# Optional: install globally to expose the slice launcher command
 npm install -g slicejs-cli
 ```
 
 ## Links
 
-- 📘 Documentation: https://slice-js-docs.vercel.app/
+- 📘 CLI Documentation: https://slice-js-docs.vercel.app/Documentation/CLI
 - 🐙 GitHub: https://github.com/VKneider/slice-cli
 - 📦 npm: https://www.npmjs.com/package/slicejs-cli
 

package/client.js

@@ -14,12 +14,18 @@ import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 import { getConfigPath, getProjectRoot } from "./commands/utils/PathHelper.js";
-import { exec } from "child_process";
+import { exec, spawnSync } from "node:child_process";
 import { promisify } from "util";
 import validations from "./commands/Validations.js";
 import Print from "./commands/Print.js";
 import build from './commands/build/build.js';
 import { cleanBundles, bundleInfo } from './commands/bundle/bundle.js';
+import {
+  isLocalDelegationDisabled,
+  findNearestLocalCliEntry,
+  resolveLocalCliCandidate,
+  shouldDelegateToLocalCli
+} from './commands/utils/LocalCliDelegation.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -84,10 +90,7 @@ async function runWithVersionCheck(commandFunction, ...args) {
       } catch {}
     })();
 
-    const updateInfo = await updateManager.checkForUpdates();
-    if (updateInfo && updateInfo.hasUpdates) {
-      await updateManager.checkAndPromptUpdates({});
-    }
+    updateManager.notifyAvailableUpdates().catch(() => {});
 
     const result = await commandFunction(...args);
 
@@ -102,6 +105,33 @@ async function runWithVersionCheck(commandFunction, ...args) {
   }
 }
 
+function maybeDelegateToLocalCli() {
+  if (isLocalDelegationDisabled(process.env)) {
+    return;
+  }
+
+  const currentEntryPath = fileURLToPath(import.meta.url);
+  const localEntryPath = findNearestLocalCliEntry(process.cwd(), resolveLocalCliCandidate);
+
+  if (!shouldDelegateToLocalCli(currentEntryPath, localEntryPath)) {
+    return;
+  }
+
+  const child = spawnSync(
+    process.execPath,
+    [localEntryPath, ...process.argv.slice(2)],
+    {
+      stdio: 'inherit',
+      cwd: process.cwd(),
+      env: process.env
+    }
+  );
+
+  process.exit(child.status ?? 1);
+}
+
+maybeDelegateToLocalCli();
+
 const sliceClient = program;
 
 try {

package/commands/utils/LocalCliDelegation.js

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

package/commands/utils/updateManager.js

@@ -13,7 +13,7 @@ import fs from "fs-extra";
 
 const execAsync = promisify(exec);
 
-class UpdateManager {
+export class UpdateManager {
     constructor() {
         this.packagesToUpdate = [];
     }
@@ -46,7 +46,9 @@ class UpdateManager {
     /**
      * Check for available updates and return structured info
      */
-    async checkForUpdates() {
+    async checkForUpdates(options = {}) {
+        const { silentErrors = false } = options;
+
         try {
             const updateInfo = await versionChecker.checkForUpdates(true); // Silent mode
 
@@ -82,11 +84,25 @@ class UpdateManager {
                 allCurrent: updateInfo.cli.status === 'current' && updateInfo.framework.status === 'current'
             };
         } catch (error) {
-            Print.error(`Checking for updates: ${error.message}`);
+            if (!silentErrors) {
+                Print.error(`Checking for updates: ${error.message}`);
+            }
             return null;
         }
     }
 
+    async notifyAvailableUpdates() {
+        const updateInfo = await this.checkForUpdates({ silentErrors: true });
+
+        if (!updateInfo || !updateInfo.hasUpdates) {
+            return false;
+        }
+
+        this.displayUpdates(updateInfo);
+        Print.info("Run 'slice update' to install updates when convenient.");
+        return true;
+    }
+
     /**
      * Display available updates in a formatted way
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slicejs-cli",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Command client for developing web applications with Slice.js framework",
   "main": "client.js",
   "bin": {

package/tests/client-launcher-contract.test.js

@@ -0,0 +1,211 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse } from '@babel/parser';
+import babelTraverse from '@babel/traverse';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const clientPath = path.join(__dirname, '..', 'client.js');
+const source = fs.readFileSync(clientPath, 'utf-8');
+const ast = parse(source, {
+  sourceType: 'module',
+  plugins: []
+});
+const traverse = babelTraverse.default || babelTraverse;
+
+function walk(node, visit) {
+  if (!node || typeof node !== 'object') {
+    return;
+  }
+
+  visit(node);
+
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        walk(item, visit);
+      }
+      continue;
+    }
+
+    walk(value, visit);
+  }
+}
+
+function getImportedBindings(fromSource) {
+  const bindings = new Map();
+
+  for (const statement of ast.program.body) {
+    if (statement.type !== 'ImportDeclaration') {
+      continue;
+    }
+
+    if (statement.source.value !== fromSource) {
+      continue;
+    }
+
+    for (const specifier of statement.specifiers) {
+      if (specifier.type === 'ImportSpecifier' && specifier.imported.type === 'Identifier') {
+        bindings.set(specifier.imported.name, specifier.local.name);
+      }
+    }
+  }
+
+  return bindings;
+}
+
+function getBoundImportedCallPositions(fromSource, importedName) {
+  const positions = [];
+  const importedBindings = getImportedBindings(fromSource);
+  const localName = importedBindings.get(importedName);
+
+  if (!localName) {
+    return positions;
+  }
+
+  traverse(ast, {
+    CallExpression(callPath) {
+      if (callPath.node.callee.type !== 'Identifier') {
+        return;
+      }
+
+      if (callPath.node.callee.name !== localName) {
+        return;
+      }
+
+      const binding = callPath.scope.getBinding(localName);
+      if (!binding) {
+        return;
+      }
+
+      if (binding.path.node.type !== 'ImportSpecifier') {
+        return;
+      }
+
+      if (binding.path.parent.type !== 'ImportDeclaration') {
+        return;
+      }
+
+      if (binding.path.parent.source.value !== fromSource) {
+        return;
+      }
+
+      if (binding.path.node.imported.type !== 'Identifier') {
+        return;
+      }
+
+      if (binding.path.node.imported.name !== importedName) {
+        return;
+      }
+
+      positions.push(callPath.node.start);
+    }
+  });
+
+  return positions;
+}
+
+function getCommandRegistrationPositions() {
+  const positions = [];
+
+  walk(ast.program, (node) => {
+    if (node.type !== 'CallExpression') {
+      return;
+    }
+
+    if (
+      node.callee.type === 'MemberExpression' &&
+      !node.callee.computed &&
+      node.callee.property.type === 'Identifier' &&
+      node.callee.property.name === 'command'
+    ) {
+      positions.push(node.start);
+    }
+  });
+
+  return positions;
+}
+
+const launcherModulePath = './commands/utils/LocalCliDelegation.js';
+const commandRegistrationPositions = getCommandRegistrationPositions();
+const firstCommandRegistrationPos = Math.min(...commandRegistrationPositions);
+
+test('client imports LocalCliDelegation utility', () => {
+  const importedBindings = getImportedBindings(launcherModulePath);
+
+  assert.ok(
+    importedBindings.size > 0,
+    'Contract clause failed: client.js must import launcher helpers from ./commands/utils/LocalCliDelegation.js'
+  );
+
+  for (const requiredImport of [
+    'isLocalDelegationDisabled',
+    'findNearestLocalCliEntry',
+    'shouldDelegateToLocalCli'
+  ]) {
+    assert.ok(
+      importedBindings.has(requiredImport),
+      `Contract clause failed: client.js must import ${requiredImport} from ${launcherModulePath}`
+    );
+  }
+});
+
+test('client checks SLICE_NO_LOCAL_DELEGATION behavior before command runtime', () => {
+  const isDisabledCalls = getBoundImportedCallPositions(
+    launcherModulePath,
+    'isLocalDelegationDisabled'
+  );
+
+  assert.ok(
+    isDisabledCalls.length > 0,
+    'Contract clause failed: client.js must call imported isLocalDelegationDisabled() in launcher path'
+  );
+
+  assert.ok(
+    commandRegistrationPositions.length > 0,
+    'Contract clause failed: client.js must define at least one .command(...) registration before launcher ordering checks'
+  );
+
+  assert.ok(
+    isDisabledCalls.some((pos) => pos < firstCommandRegistrationPos),
+    'Contract clause failed: isLocalDelegationDisabled() must be evaluated before command registration/runtime wiring'
+  );
+});
+
+test('client performs local candidate resolution and delegation decision', () => {
+  const findNearestCalls = getBoundImportedCallPositions(
+    launcherModulePath,
+    'findNearestLocalCliEntry'
+  );
+  const shouldDelegateCalls = getBoundImportedCallPositions(
+    launcherModulePath,
+    'shouldDelegateToLocalCli'
+  );
+
+  assert.ok(
+    findNearestCalls.length > 0,
+    'Contract clause failed: client.js must call imported findNearestLocalCliEntry() to resolve local CLI candidate in launcher path'
+  );
+
+  assert.ok(
+    shouldDelegateCalls.length > 0,
+    'Contract clause failed: client.js must call imported shouldDelegateToLocalCli() to gate delegation in launcher path'
+  );
+
+  assert.ok(
+    commandRegistrationPositions.length > 0,
+    'Contract clause failed: client.js must define at least one .command(...) registration before launcher ordering checks'
+  );
+
+  assert.ok(
+    findNearestCalls.some((pos) => pos < firstCommandRegistrationPos),
+    'Contract clause failed: findNearestLocalCliEntry() must execute before command registration/runtime wiring'
+  );
+
+  assert.ok(
+    shouldDelegateCalls.some((pos) => pos < firstCommandRegistrationPos),
+    'Contract clause failed: shouldDelegateToLocalCli() must execute before command registration/runtime wiring'
+  );
+});

package/tests/client-update-flow-contract.test.js

@@ -0,0 +1,272 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse } from '@babel/parser';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const clientPath = path.join(__dirname, '..', 'client.js');
+const clientSource = fs.readFileSync(clientPath, 'utf-8');
+const ast = parse(clientSource, {
+  sourceType: 'module',
+  errorRecovery: true,
+  loc: true,
+  ranges: true
+});
+
+function lineOf(node) {
+  return node && node.loc && node.loc.start ? node.loc.start.line : null;
+}
+
+function walk(node, visit) {
+  if (!node || typeof node !== 'object') {
+    return;
+  }
+
+  visit(node);
+
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        walk(item, visit);
+      }
+      continue;
+    }
+
+    walk(value, visit);
+  }
+}
+
+function isMethodCall(node, methodName) {
+  return (
+    node &&
+    node.type === 'CallExpression' &&
+    node.callee &&
+    node.callee.type === 'MemberExpression' &&
+    node.callee.property &&
+    node.callee.property.type === 'Identifier' &&
+    node.callee.property.name === methodName
+  );
+}
+
+function isCommandUpdateExpression(node) {
+  if (!node || node.type !== 'CallExpression') {
+    return false;
+  }
+
+  if (
+    node.callee &&
+    node.callee.type === 'MemberExpression' &&
+    node.callee.property &&
+    node.callee.property.type === 'Identifier' &&
+    node.callee.property.name === 'command' &&
+    node.arguments[0] &&
+    node.arguments[0].type === 'StringLiteral' &&
+    node.arguments[0].value === 'update'
+  ) {
+    return true;
+  }
+
+  if (node.callee && node.callee.type === 'MemberExpression') {
+    return isCommandUpdateExpression(node.callee.object);
+  }
+
+  return false;
+}
+
+function getRunWithVersionCheckNode() {
+  let foundNode = null;
+
+  walk(ast, (node) => {
+    if (
+      node.type === 'FunctionDeclaration' &&
+      node.id &&
+      node.id.type === 'Identifier' &&
+      node.id.name === 'runWithVersionCheck'
+    ) {
+      foundNode = node;
+      return;
+    }
+
+    if (node.type !== 'VariableDeclarator') {
+      return;
+    }
+
+    if (!node.id || node.id.type !== 'Identifier' || node.id.name !== 'runWithVersionCheck') {
+      return;
+    }
+
+    if (
+      node.init &&
+      (node.init.type === 'ArrowFunctionExpression' || node.init.type === 'FunctionExpression')
+    ) {
+      foundNode = node.init;
+    }
+  });
+
+  return foundNode;
+}
+
+function getFunctionBodyNode(fnNode) {
+  if (!fnNode) {
+    return null;
+  }
+
+  if (fnNode.type === 'FunctionDeclaration' || fnNode.type === 'FunctionExpression' || fnNode.type === 'ArrowFunctionExpression') {
+    return fnNode.body;
+  }
+
+  return null;
+}
+
+function getFunctionLikeByName(name) {
+  let foundNode = null;
+
+  walk(ast, (node) => {
+    if (
+      node.type === 'FunctionDeclaration' &&
+      node.id &&
+      node.id.type === 'Identifier' &&
+      node.id.name === name
+    ) {
+      foundNode = node;
+      return;
+    }
+
+    if (node.type !== 'VariableDeclarator') {
+      return;
+    }
+
+    if (!node.id || node.id.type !== 'Identifier' || node.id.name !== name) {
+      return;
+    }
+
+    if (
+      node.init &&
+      (node.init.type === 'ArrowFunctionExpression' || node.init.type === 'FunctionExpression')
+    ) {
+      foundNode = node.init;
+    }
+  });
+
+  return foundNode;
+}
+
+test('runWithVersionCheck uses non-blocking update notifications', () => {
+  const runWithVersionCheckNode = getRunWithVersionCheckNode();
+  const runWithVersionCheckBody = getFunctionBodyNode(runWithVersionCheckNode);
+
+  assert.ok(
+    runWithVersionCheckNode,
+    'runWithVersionCheck function should exist as a declaration or function-valued variable'
+  );
+  assert.ok(runWithVersionCheckBody, 'runWithVersionCheck should have a traversable function body');
+
+  let hasNotifyCall = false;
+  let hasAwaitedNotifyCall = false;
+  let notifyCallLine = null;
+  let hasPromptCall = false;
+  let promptCallLine = null;
+
+  walk(runWithVersionCheckBody, (node) => {
+    if (isMethodCall(node, 'notifyAvailableUpdates')) {
+      hasNotifyCall = true;
+      notifyCallLine = notifyCallLine ?? lineOf(node);
+    }
+    if (
+      node.type === 'AwaitExpression' &&
+      isMethodCall(node.argument, 'notifyAvailableUpdates')
+    ) {
+      hasAwaitedNotifyCall = true;
+    }
+    if (isMethodCall(node, 'checkAndPromptUpdates')) {
+      hasPromptCall = true;
+      promptCallLine = promptCallLine ?? lineOf(node);
+    }
+  });
+
+  assert.equal(
+    hasNotifyCall,
+    true,
+    `runWithVersionCheck must call updateManager.notifyAvailableUpdates() (found at line ${notifyCallLine ?? 'unknown'})`
+  );
+  assert.equal(
+    hasAwaitedNotifyCall,
+    false,
+    `runWithVersionCheck should fire-and-forget notifyAvailableUpdates() without await (notify call line ${notifyCallLine ?? 'unknown'})`
+  );
+  assert.equal(
+    hasPromptCall,
+    false,
+    `runWithVersionCheck must not call updateManager.checkAndPromptUpdates() (found at line ${promptCallLine ?? 'unknown'})`
+  );
+});
+
+test('update command remains explicitly interactive', () => {
+  let foundAwaitedInteractiveUpdateAction = false;
+  let updateActionHandlerLine = null;
+  let relatedPromptCallLine = null;
+  let handlerReferenceName = null;
+
+  walk(ast, (node) => {
+    if (
+      node.type === 'CallExpression' &&
+      node.callee &&
+      node.callee.type === 'MemberExpression' &&
+      node.callee.property &&
+      node.callee.property.type === 'Identifier' &&
+      node.callee.property.name === 'action' &&
+      isCommandUpdateExpression(node.callee.object)
+    ) {
+      const actionHandler = node.arguments[0];
+      if (!actionHandler) {
+        return;
+      }
+
+      let resolvedHandler = null;
+
+      if (actionHandler.type === 'Identifier') {
+        handlerReferenceName = actionHandler.name;
+        resolvedHandler = getFunctionLikeByName(actionHandler.name);
+      } else if (
+        actionHandler.type === 'ArrowFunctionExpression' ||
+        actionHandler.type === 'FunctionExpression'
+      ) {
+        resolvedHandler = actionHandler;
+      }
+
+      if (!resolvedHandler || resolvedHandler.async !== true) {
+        return;
+      }
+
+      const resolvedBody = getFunctionBodyNode(resolvedHandler);
+      if (!resolvedBody) {
+        return;
+      }
+
+      updateActionHandlerLine = updateActionHandlerLine ?? lineOf(resolvedHandler);
+
+      walk(resolvedBody, (actionNode) => {
+        if (isMethodCall(actionNode, 'checkAndPromptUpdates')) {
+          relatedPromptCallLine = relatedPromptCallLine ?? lineOf(actionNode);
+        }
+
+        if (
+          actionNode.type !== 'AwaitExpression' ||
+          !isMethodCall(actionNode.argument, 'checkAndPromptUpdates')
+        ) {
+          return;
+        }
+
+        foundAwaitedInteractiveUpdateAction = true;
+      });
+    }
+  });
+
+  assert.equal(
+    foundAwaitedInteractiveUpdateAction,
+    true,
+    `update command action must await checkAndPromptUpdates(...) (action line ${updateActionHandlerLine ?? 'unknown'}, related call line ${relatedPromptCallLine ?? 'unknown'}${handlerReferenceName ? `, handler reference ${handlerReferenceName}` : ''})`
+  );
+});

package/tests/local-cli-delegation.test.js

@@ -0,0 +1,79 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  findNearestLocalCliEntry,
+  resolveLocalCliCandidate,
+  shouldDelegateToLocalCli,
+  isLocalDelegationDisabled
+} from '../commands/utils/LocalCliDelegation.js';
+
+test('isLocalDelegationDisabled returns true when env flag is set', () => {
+  const env = { SLICE_NO_LOCAL_DELEGATION: '1' };
+  assert.equal(isLocalDelegationDisabled(env), true);
+});
+
+test('isLocalDelegationDisabled returns false when env flag is missing', () => {
+  const env = {};
+  assert.equal(isLocalDelegationDisabled(env), false);
+});
+
+test('shouldDelegateToLocalCli is false when candidate is null', () => {
+  assert.equal(shouldDelegateToLocalCli('/tmp/current/client.js', null), false);
+});
+
+test('shouldDelegateToLocalCli is false when candidate realpath equals current realpath', () => {
+  const same = '/tmp/current/client.js';
+  assert.equal(shouldDelegateToLocalCli(same, same), false);
+});
+
+test('shouldDelegateToLocalCli is true when candidate differs from current', () => {
+  const current = '/tmp/global/client.js';
+  const local = '/tmp/project/node_modules/slicejs-cli/client.js';
+  assert.equal(shouldDelegateToLocalCli(current, local), true);
+});
+
+test('findNearestLocalCliEntry returns null when no candidate resolver hits', () => {
+  const cwd = path.join('/tmp', 'slice-nonexistent-project');
+  const resolver = () => null;
+  const result = findNearestLocalCliEntry(cwd, resolver);
+  assert.equal(result, null);
+});
+
+test('findNearestLocalCliEntry returns first match while traversing upward', () => {
+  const cwd = '/repo/apps/web/src';
+  const calls = [];
+  const resolver = (dir) => {
+    calls.push(dir);
+    if (dir === '/repo/apps/web') {
+      return '/repo/apps/web/node_modules/slicejs-cli/client.js';
+    }
+    return null;
+  };
+
+  const result = findNearestLocalCliEntry(cwd, resolver);
+
+  assert.equal(result, '/repo/apps/web/node_modules/slicejs-cli/client.js');
+  assert.deepEqual(calls, ['/repo/apps/web/src', '/repo/apps/web']);
+});
+
+test('findNearestLocalCliEntry returns null when resolver is not a function', () => {
+  const result = findNearestLocalCliEntry('/repo/apps/web/src', null);
+  assert.equal(result, null);
+});
+
+test('resolveLocalCliCandidate returns null when candidate path is a directory', () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'slice-cli-delegation-'));
+  const candidateDirectory = path.join(tempRoot, 'node_modules', 'slicejs-cli', 'client.js');
+
+  fs.mkdirSync(candidateDirectory, { recursive: true });
+
+  try {
+    const result = resolveLocalCliCandidate(tempRoot);
+    assert.equal(result, null);
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+});

package/tests/update-manager-notifications.test.js

@@ -0,0 +1,88 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import Print from '../commands/Print.js';
+import { UpdateManager } from '../commands/utils/updateManager.js';
+
+test('notifyAvailableUpdates shows advisory output and never invokes interactive update flow', async () => {
+  const manager = new UpdateManager();
+  const calls = {
+    display: 0,
+    prompted: 0,
+    info: [],
+    error: []
+  };
+
+  manager.checkForUpdates = async () => ({
+    hasUpdates: true,
+    updates: [
+      {
+        name: 'slicejs-web-framework',
+        displayName: 'Slice.js Framework',
+        current: '2.4.3',
+        latest: '2.5.0',
+        type: 'framework'
+      }
+    ],
+    allCurrent: false
+  });
+
+  manager.displayUpdates = () => {
+    calls.display += 1;
+  };
+
+  manager.checkAndPromptUpdates = async () => {
+    calls.prompted += 1;
+    return true;
+  };
+
+  const originalInfo = Print.info;
+  const originalError = Print.error;
+
+  Print.info = (message) => calls.info.push(message);
+  Print.error = (message) => calls.error.push(message);
+
+  try {
+    const result = await manager.notifyAvailableUpdates();
+
+    assert.equal(result, true);
+    assert.equal(calls.display, 1);
+    assert.equal(calls.prompted, 0);
+    assert.equal(calls.error.length, 0);
+    assert.equal(calls.info.length, 1);
+    assert.match(calls.info[0], /slice update/);
+  } finally {
+    Print.info = originalInfo;
+    Print.error = originalError;
+  }
+});
+
+test('notifyAvailableUpdates returns false and prints nothing when no updates are available', async () => {
+  const manager = new UpdateManager();
+  const calls = {
+    display: 0,
+    info: []
+  };
+
+  manager.checkForUpdates = async () => ({
+    hasUpdates: false,
+    updates: [],
+    allCurrent: true
+  });
+
+  manager.displayUpdates = () => {
+    calls.display += 1;
+  };
+
+  const originalInfo = Print.info;
+  Print.info = (message) => calls.info.push(message);
+
+  try {
+    const result = await manager.notifyAvailableUpdates();
+
+    assert.equal(result, false);
+    assert.equal(calls.display, 0);
+    assert.equal(calls.info.length, 0);
+  } finally {
+    Print.info = originalInfo;
+  }
+});