slicejs-cli 3.2.0 → 3.4.0

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

@@ -1,79 +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 });
-  }
-});
+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/postinstall-command.test.js

@@ -0,0 +1,72 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const clientPath = path.join(__dirname, '..', 'client.js');
+const source = fs.readFileSync(clientPath, 'utf-8');
+
+test('postinstall command is registered in client.js', () => {
+  const hasSetupCommand = source.includes('.command("postinstall")');
+  assert.ok(hasSetupCommand, 'client.js must register a "postinstall" command');
+});
+
+test('postinstall command has a description', () => {
+  const match = source.match(/\.command\(["']postinstall["']\)\s*\.description\(["']([^"']+)["']\)/);
+  assert.ok(match, 'postinstall command must have a .description() call');
+  assert.ok(match[1].length > 0, 'postinstall command description must not be empty');
+});
+
+test('postinstall command checks npm_config_global environment variable', () => {
+  const hasGlobalCheck = source.includes('npm_config_global');
+  assert.ok(hasGlobalCheck, 'postinstall command must check npm_config_global to detect global installation');
+});
+
+test('postinstall command prints global install warning', () => {
+  const hasGlobalWarning = source.includes('Global installation');
+  assert.ok(hasGlobalWarning, 'postinstall command must warn about global installation');
+});
+
+test('postinstall command prints local install success message', () => {
+  const hasSuccessMsg = source.includes('installed successfully');
+  assert.ok(hasSuccessMsg, 'postinstall command must show success message for local installs');
+});
+
+test('postinstall command uses getProjectRoot from PathHelper', () => {
+  const hasPathHelper = source.includes("getProjectRoot(import.meta.url)");
+  assert.ok(hasPathHelper, 'postinstall command must use getProjectRoot resolver');
+});
+
+test('postinstall command writes npm scripts to package.json via fs', () => {
+  const hasFsWrite = source.includes('writeFileSync(pkgPath');
+  assert.ok(hasFsWrite, 'postinstall command must write scripts to package.json');
+});
+
+test('postinstall command writes slice:dev script to package.json', () => {
+  const hasDevScript = source.includes("'slice:dev': 'slice dev'");
+  assert.ok(hasDevScript, 'postinstall command must add "slice:dev" script to package.json');
+});
+
+test('postinstall command writes all slice:* scripts to package.json', () => {
+  const scripts = [
+    'slice:dev', 'slice:start', 'slice:create', 'slice:list',
+    'slice:delete', 'slice:init', 'slice:get', 'slice:browse',
+    'slice:sync', 'slice:version', 'slice:update'
+  ];
+  for (const script of scripts) {
+    assert.ok(source.includes(script), `postinstall command must configure ${script} script`);
+  }
+});
+
+test('postinstall command action is a function', () => {
+  const SetupActionPattern = /\.command\(["']postinstall["']\)[\s\S]*?\.action\(\(\)\s*=>\s*\{[\s\S]*?\}\)/;
+  const match = source.match(SetupActionPattern);
+  assert.ok(match, 'postinstall command must have an .action() with arrow function');
+});
+
+test('postinstall command provides npm uninstall -g instruction for global installs', () => {
+  const hasUninstallInstruction = source.includes('npm uninstall -g slicejs-cli');
+  assert.ok(hasUninstallInstruction, 'postinstall command must tell users how to uninstall global CLI');
+});

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

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

package/refactor.md

@@ -1,271 +0,0 @@
-# Plan de Refactorización del CLI para MCP
-
-## Objetivo
-Separar la lógica de negocio de la presentación CLI para permitir importación directa desde el MCP server, manteniendo **100% de compatibilidad** con el CLI actual.
-
----
-
-## Estructura Propuesta
-
-```
-commands/
-├── createComponent/
-│   ├── createComponent.js        # CLI wrapper (presentación)
-│   ├── core.js                   # ⭐ NUEVO - Lógica pura exportable
-│   └── VisualComponentTemplate.js
-│
-├── listComponents/
-│   ├── listComponents.js         # CLI wrapper (presentación)
-│   └── core.js                   # ⭐ NUEVO - Lógica pura exportable
-│
-├── deleteComponent/
-│   ├── deleteComponent.js        # CLI wrapper (presentación)
-│   └── core.js                   # ⭐ NUEVO - Lógica pura exportable
-│
-├── getComponent/
-│   ├── getComponent.js           # CLI wrapper (presentación)
-│   └── core.js                   # ⭐ NUEVO - Lógica pura exportable
-│
-└── init/
-    ├── init.js                   # CLI wrapper (presentación)
-    └── core.js                   # ⭐ NUEVO - Lógica pura exportable
-```
-
----
-
-## Principios de Refactorización
-
-### 1. Separación de Responsabilidades
-- **core.js**: Lógica pura sin dependencias de CLI (Print, chalk, Table, inquirer)
-- **[comando].js**: Solo presentación CLI, usa funciones del core
-
-### 2. Funciones Puras en Core
-- Reciben parámetros explícitos (no usan import.meta.url implícitamente)
-- Retornan objetos con estructura `{ success: boolean, data?, error? }`
-- No imprimen a consola directamente
-- Son agnósticas del entorno (CLI vs MCP)
-
-### 3. Compatibilidad Total
-- Los archivos CLI actuales se mantienen funcionales
-- Misma API de comandos
-- Mismo comportamiento observable
-- No romper ningún test existente
-
----
-
-## Pasos de Refactorización por Comando
-
-### Fase 1: List Components
-
-#### Paso 1.1: Análisis del Código Actual
-- Identificar toda la lógica de negocio en `listComponents.js`
-- Separar mentalmente: lógica vs presentación
-- Funciones a extraer: `loadConfig`, `getComponents`, `countComponentFiles`, `listComponentDirectories`
-
-#### Paso 1.2: Crear core.js
-- Crear archivo `commands/listComponents/core.js`
-- Extraer funciones de lógica pura
-- Modificar para que acepten `projectPath` como parámetro opcional
-- Retornar objetos estructurados en lugar de imprimir
-
-#### Paso 1.3: Adaptar listComponents.js
-- Importar funciones desde `core.js`
-- Mantener solo la lógica de presentación (Print, Table, chalk)
-- Re-exportar funciones del core: `export { getComponents, ... } from './core.js'`
-
-#### Paso 1.4: Verificación
-- Ejecutar `slice list` - debe funcionar idéntico
-- Probar importación directa: `import { getComponents } from './commands/listComponents/core.js'`
-- Verificar que retorna datos correctos sin CLI
-
----
-
-### Fase 2: Create Component
-
-#### Paso 2.1: Análisis
-- Identificar lógica: validaciones, generación de templates, creación de archivos
-- Identificar presentación: mensajes de error, comandos de ejemplo
-
-#### Paso 2.2: Crear core.js
-- Crear `commands/createComponent/core.js`
-- Extraer: `validateComponentName`, `validateCategory`, `generateTemplate`, `createComponentFiles`
-- Cada función retorna `{ success, data, error }`
-
-#### Paso 2.3: Adaptar createComponent.js
-- Importar funciones del core
-- Mantener solo los Print y mensajes de ayuda
-- Re-exportar funciones del core
-
-#### Paso 2.4: Verificación
-- Ejecutar `slice component create` - debe funcionar igual
-- Probar importación directa y creación programática
-
----
-
-### Fase 3: Delete Component
-
-#### Paso 3.1: Análisis
-- Identificar lógica: validaciones, verificación de existencia, eliminación de archivos
-- Identificar presentación: mensajes de confirmación, errores
-
-#### Paso 3.2: Crear core.js
-- Crear `commands/deleteComponent/core.js`
-- Extraer: `deleteComponentFiles` (con validaciones integradas)
-
-#### Paso 3.3: Adaptar deleteComponent.js
-- Importar del core
-- Mantener presentación CLI
-- Re-exportar funciones
-
-#### Paso 3.4: Verificación
-- Ejecutar `slice component delete`
-- Verificar funcionamiento idéntico
-
----
-
-### Fase 4: Get Component (Registry)
-
-#### Paso 4.1: Análisis
-- Identificar lógica: descarga de registry, instalación de componentes, actualización
-- Es el más complejo - tiene clase ComponentRegistry
-
-#### Paso 4.2: Crear core.js
-- Crear `commands/getComponent/core.js`
-- Extraer clase `ComponentRegistry` limpia (sin inquirer, sin Print)
-- Métodos retornan objetos estructurados
-
-#### Paso 4.3: Adaptar getComponent.js
-- Importar ComponentRegistry del core
-- Envolver con lógica interactiva (inquirer) solo en CLI
-- Mantener funciones: `getComponents`, `listComponents`, `syncComponents`
-
-#### Paso 4.4: Verificación
-- Probar: `slice get Button`, `slice browse`, `slice sync`
-- Verificar descarga y registro correctos
-
----
-
-### Fase 5: Init Project
-
-#### Paso 5.1: Análisis
-- Identificar lógica: copia de estructuras, configuración de package.json
-- Separar spinners y mensajes visuales
-
-#### Paso 5.2: Crear core.js
-- Crear `commands/init/core.js`
-- Extraer: funciones de scaffolding, configuración
-
-#### Paso 5.3: Adaptar init.js
-- Importar del core
-- Mantener spinners y presentación
-- Re-exportar funciones
-
-#### Paso 5.4: Verificación
-- Ejecutar `slice init` en proyecto nuevo
-- Verificar estructura completa creada
-
----
-
-## Patrón de Estructura de Funciones Core
-
-### Firma de Función Estándar
-```
-function operationName({ param1, param2, projectPath = null }) {
-    // Validaciones
-    // Lógica de negocio
-    return { success: boolean, data?, error? }
-}
-```
-
-### Objeto de Retorno Estándar
-```javascript
-// Éxito
-{
-    success: true,
-    data: { ... },
-    // Campos adicionales específicos
-}
-
-// Error
-{
-    success: false,
-    error: "mensaje descriptivo"
-}
-```
-
----
-
-## Estrategia de Dependencias
-
-### Dependencias Permitidas en core.js
-- ✅ `fs`, `fs-extra`
-- ✅ `path`
-- ✅ `Validations.js` (lógica pura)
-- ✅ Helpers de PathHelper (refactorizar para aceptar projectPath)
-
-### Dependencias NO Permitidas en core.js
-- ❌ `Print.js` (específico de CLI)
-- ❌ `chalk` (presentación)
-- ❌ `cli-table3` (presentación)
-- ❌ `inquirer` (interacción CLI)
-- ❌ `ora` (spinners CLI)
-
----
-
-## Refactorización de PathHelper
-
-### Problema Actual
-PathHelper usa `import.meta.url` internamente, asumiendo que se llama desde dentro del CLI
-
-### Solución
-Crear versiones alternativas que acepten `projectPath`:
-
-```
-// Versión CLI (actual)
-getSrcPath(import.meta.url, ...paths)
-
-// Versión core (nueva)
-getProjectSrcPath(projectPath, ...paths)
-```
-
-O mejor: modificar funciones existentes para aceptar ambos modos:
-```
-getSrcPath(importMetaUrlOrProjectPath, ...paths)
-```
-
----
-
-## Testing de la Refactorización
-
-### Test 1: CLI Functionality
-Para cada comando refactorizado:
-- Ejecutar comando CLI
-- Verificar output idéntico al anterior
-- Verificar archivos creados/modificados
-
-### Test 2: Importación Directa
-```javascript
-// test-mcp-import.js
-import { getComponents } from './commands/listComponents/core.js';
-
-const result = getComponents('/ruta/proyecto');
-console.log(result); // Debe retornar objeto con componentes
-```
-
-### Test 3: Sin Dependencias CLI
-Verificar que core.js no tiene imports de Print, chalk, etc:
-```bash
-grep -r "from.*Print" commands/*/core.js  # debe estar vacío
-grep -r "from.*chalk" commands/*/core.js  # debe estar vacío
-```
-
----
-
-## Orden de Implementación Recomendado
-
-1. **listComponents** (más simple, establece patrón)
-2. **createComponent** (complejidad media)
-3. **deleteComponent** (similar a create)
-4. **getComponent** (más complejo, tiene clase)
-5. **init** (el más complejo)
-