slicejs-cli 3.0.0 → 3.0.3

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.3",
   "description": "Command client for developing web applications with Slice.js framework",
   "main": "client.js",
   "bin": {

package/tests/bundle-generator.test.js

@@ -204,3 +204,185 @@ test('rebalance merge preserves and merges route path metadata deterministically
   assert.equal(Object.keys(bundles).length, 2);
   assert.deepEqual(bundles.beta.paths, ['/beta', '/beta-alt', '/gamma']);
 });
+
+test('stripImports preserves absolute imports from configured publicFolders', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {},
+    sliceConfig: {
+      publicFolders: ['/public', '/assets']
+    }
+  });
+
+  const source = "import logo from '/public/logo.js';\nimport hero from '/assets/hero.js';\nclass Demo {}\n";
+  const cleaned = generator.stripImports(source);
+
+  assert.match(cleaned, /import\s+logo\s+from\s+'\/public\/logo\.js';/);
+  assert.match(cleaned, /import\s+hero\s+from\s+'\/assets\/hero\.js';/);
+});
+
+test('stripImports removes relative imports', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {},
+    sliceConfig: {
+      publicFolders: ['/public']
+    }
+  });
+
+  const source = "import localDep from './local.js';\nimport parentDep from '../parent.js';\nclass Demo {}\n";
+  const cleaned = generator.stripImports(source);
+
+  assert.doesNotMatch(cleaned, /\.\/local\.js/);
+  assert.doesNotMatch(cleaned, /\.\.\/parent\.js/);
+  assert.match(cleaned, /class Demo \{\}/);
+});
+
+test('stripImports warns on bare imports', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {},
+    sliceConfig: {
+      publicFolders: ['/public']
+    }
+  });
+
+  const warnings = [];
+  const originalWarn = console.warn;
+  console.warn = (...args) => warnings.push(args.join(' '));
+
+  try {
+    const source = "import { html } from 'lit';\nclass Demo {}\n";
+    const cleaned = generator.stripImports(source);
+
+    assert.doesNotMatch(cleaned, /from\s+'lit'/);
+    assert.ok(warnings.some((msg) => msg.includes('bare import') && msg.includes('lit')));
+  } finally {
+    console.warn = originalWarn;
+  }
+});
+
+test('stripImports warns on absolute imports outside publicFolders', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {},
+    sliceConfig: {
+      publicFolders: ['/public']
+    }
+  });
+
+  const warnings = [];
+  const originalWarn = console.warn;
+  console.warn = (...args) => warnings.push(args.join(' '));
+
+  try {
+    const source = "import secret from '/private/secret.js';\nclass Demo {}\n";
+    const cleaned = generator.stripImports(source);
+
+    assert.doesNotMatch(cleaned, /\/private\/secret\.js/);
+    assert.ok(warnings.some((msg) => msg.includes('outside publicFolders') && msg.includes('/private/secret.js')));
+  } finally {
+    console.warn = originalWarn;
+  }
+});
+
+test('stripImports supports side-effect and multiline imports in fallback mode', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {},
+    sliceConfig: {
+      publicFolders: ['/public']
+    }
+  });
+
+  const warnings = [];
+  const originalWarn = console.warn;
+  console.warn = (...args) => warnings.push(args.join(' '));
+
+  const originalParse = generator.parseImportsFromCode;
+  generator.parseImportsFromCode = () => {
+    throw new Error('forced parser failure');
+  };
+
+  try {
+    const source = [
+      "import '/public/effects.js';",
+      "import '/private/effects.js';",
+      "import {",
+      '  html,',
+      '  css',
+      "} from 'lit';",
+      'class Demo {}'
+    ].join('\n');
+    const cleaned = generator.stripImports(source, { sourceContext: 'DemoComponent' });
+
+    assert.match(cleaned, /import '\/public\/effects\.js';/);
+    assert.doesNotMatch(cleaned, /\/private\/effects\.js/);
+    assert.doesNotMatch(cleaned, /from 'lit'/);
+    assert.ok(warnings.some((msg) => msg.includes('outside publicFolders') && msg.includes('/private/effects.js') && msg.includes('[DemoComponent]')));
+    assert.ok(warnings.some((msg) => msg.includes('bare import') && msg.includes('lit') && msg.includes('[DemoComponent]')));
+  } finally {
+    generator.parseImportsFromCode = originalParse;
+    console.warn = originalWarn;
+  }
+});
+
+test('cleanJavaScript hoists allowed absolute imports and removes them from component code', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {},
+    sliceConfig: {
+      publicFolders: ['/public']
+    }
+  });
+
+  const source = [
+    "import hero from '/public/hero.js';",
+    'class Demo extends HTMLElement {}',
+    'customElements.define("x-demo", Demo);'
+  ].join('\n');
+
+  const result = generator.cleanJavaScript(source, 'Demo', 'DemoPath.js');
+
+  assert.doesNotMatch(result.code, /import hero from '\/public\/hero\.js';/);
+  assert.ok(result.hoistedImports.includes("import hero from '/public/hero.js';"));
+});
+
+test('formatBundleFile emits hoisted imports for framework-compatible output', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {}
+  });
+
+  const source = generator.formatBundleFile({
+    'Framework/Structural/Bootstrap': {
+      name: 'Bootstrap',
+      category: 'Framework',
+      categoryType: 'Structural',
+      componentDependencies: [],
+      externalDependencies: {},
+      hoistedImports: ["import boot from '/public/bootstrap.js';"],
+      js: 'class Bootstrap extends HTMLElement {}\nreturn Bootstrap;',
+      html: '',
+      css: '',
+      size: 10,
+      isFramework: true
+    }
+  }, {
+    type: 'framework',
+    generated: new Date().toISOString(),
+    strategy: 'hybrid',
+    componentCount: 1,
+    totalSize: 10
+  });
+
+  assert.match(source, /import boot from '\/public\/bootstrap\.js';/);
+  assert.match(source, /const SLICE_BUNDLE_DEPENDENCIES = \{\};/);
+});

package/tests/bundle-v2-register-output.test.js

@@ -139,3 +139,113 @@ test('bundle output inlines dependency modules and binds imported symbols in cla
   assert.match(source, /SLICE_BUNDLE_DEPENDENCIES\["App\/documentationRoutes\.js"\] = __sliceDepExports0;/);
   assert.match(source, /const documentationRoutes = SLICE_BUNDLE_DEPENDENCIES\["App\/documentationRoutes\.js"\]\.documentationRoutes;/);
 });
+
+test('bundle output hoists allowed absolute imports to module top-level', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {
+      totalComponents: 0,
+      totalRoutes: 0,
+      sharedPercentage: 0,
+      totalSize: 0
+    }
+  }, { output: 'src' });
+
+  const source = generator.generateBundleFileContent(
+    'slice-bundle.test.js',
+    'route',
+    [{
+      name: 'HeroCard',
+      category: 'Visual',
+      categoryType: 'Visual',
+      dependencies: new Set(),
+      size: 100,
+      js: 'class HeroCard extends HTMLElement {}\nwindow.HeroCard = HeroCard;\nreturn HeroCard;',
+      html: '',
+      css: '',
+      hoistedImports: ["import hero from '/public/hero.js';"]
+    }],
+    '/test'
+  );
+
+  assert.match(source, /import hero from '\/public\/hero\.js';/);
+  assert.doesNotMatch(source, /SLICE_CLASS_FACTORY_SliceComponent_HeroCard = \(\) => \{[\s\S]*import hero from '\/public\/hero\.js';/);
+});
+
+test('generateBundleFileContent throws on hoisted import local binding collisions', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {
+      totalComponents: 0,
+      totalRoutes: 0,
+      sharedPercentage: 0,
+      totalSize: 0
+    }
+  }, { output: 'src' });
+
+  assert.throws(() => {
+    generator.generateBundleFileContent(
+      'slice-bundle.test.js',
+      'route',
+      [
+        {
+          name: 'CompA',
+          category: 'Visual',
+          categoryType: 'Visual',
+          dependencies: new Set(),
+          size: 100,
+          js: 'class CompA extends HTMLElement {}\nwindow.CompA = CompA;\nreturn CompA;',
+          html: '',
+          css: '',
+          hoistedImports: ["import foo from '/public/a.js';"]
+        },
+        {
+          name: 'CompB',
+          category: 'Visual',
+          categoryType: 'Visual',
+          dependencies: new Set(),
+          size: 100,
+          js: 'class CompB extends HTMLElement {}\nwindow.CompB = CompB;\nreturn CompB;',
+          html: '',
+          css: '',
+          hoistedImports: ["import foo from '/public/b.js';"]
+        }
+      ],
+      '/test'
+    );
+  }, /Hoisted import binding collision: foo/);
+});
+
+test('generateBundleFileContent throws on reserved identifier collision', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {
+      totalComponents: 0,
+      totalRoutes: 0,
+      sharedPercentage: 0,
+      totalSize: 0
+    }
+  }, { output: 'src' });
+
+  assert.throws(() => {
+    generator.generateBundleFileContent(
+      'slice-bundle.test.js',
+      'route',
+      [{
+        name: 'CompMeta',
+        category: 'Visual',
+        categoryType: 'Visual',
+        dependencies: new Set(),
+        size: 100,
+        js: 'class CompMeta extends HTMLElement {}\nwindow.CompMeta = CompMeta;\nreturn CompMeta;',
+        html: '',
+        css: '',
+        hoistedImports: ["import SLICE_BUNDLE_META from '/public/meta.js';"]
+      }],
+      '/test'
+    );
+  }, /reserved identifier collision: SLICE_BUNDLE_META/);
+});

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