@fprad0/skill-master-mcp 0.0.12 → 1.0.1

package/bin/lib/operation-result.mjs

@@ -0,0 +1,59 @@
+export const OPERATION_EXIT_CODES = {
+  ok: 0,
+  warning: 10,
+  error: 20,
+  fatal: 30,
+};
+
+export function classifyOperationResult(code) {
+  const numericCode = Number.isFinite(Number(code)) ? Number(code) : 1;
+
+  if (numericCode === OPERATION_EXIT_CODES.ok) {
+    return { kind: 'ok', code: numericCode };
+  }
+
+  if (numericCode === OPERATION_EXIT_CODES.warning) {
+    return { kind: 'warning', code: numericCode };
+  }
+
+  if (numericCode >= OPERATION_EXIT_CODES.fatal) {
+    return { kind: 'fatal', code: numericCode };
+  }
+
+  return { kind: 'error', code: numericCode };
+}
+
+export function buildOperationResultCopy(code) {
+  const result = classifyOperationResult(code);
+
+  if (result.kind === 'ok') {
+    return {
+      kind: result.kind,
+      code: result.code,
+      frameTitle: 'result-ok',
+      heading: 'SUBROUTINE COMPLETE',
+      summary: 'Comando concluido com sucesso.',
+      next: 'workflow liberado para a proxima acao',
+    };
+  }
+
+  if (result.kind === 'warning') {
+    return {
+      kind: result.kind,
+      code: result.code,
+      frameTitle: 'result-warn',
+      heading: 'SUBROUTINE COMPLETE WITH WARNINGS',
+      summary: 'Comando concluido com avisos.',
+      next: 'workflow liberado, mas existe uma acao recomendada',
+    };
+  }
+
+  return {
+    kind: result.kind,
+    code: result.code,
+    frameTitle: 'result-error',
+    heading: 'SUBROUTINE FAILED',
+    summary: `Comando terminou com codigo ${result.code}.`,
+    next: 'verifique o log acima antes de continuar',
+  };
+}

package/bin/lib/register-clients-core.mjs

@@ -0,0 +1,247 @@
+import path from 'node:path';
+import process from 'node:process';
+import { spawnSync } from 'node:child_process';
+import { formatShellCommand } from './client-config.mjs';
+import { OPERATION_EXIT_CODES } from './operation-result.mjs';
+
+function trimOutput(value) {
+  return String(value ?? '').trim();
+}
+
+function normalizeProcessResult(result = {}) {
+  return {
+    status: Number.isInteger(result.status) ? result.status : null,
+    signal: result.signal ?? null,
+    stdout: trimOutput(result.stdout),
+    stderr: trimOutput(result.stderr),
+    error: result.error
+      ? {
+          code: result.error.code ?? null,
+          message: result.error.message ?? String(result.error),
+        }
+      : null,
+  };
+}
+
+function firstNonEmpty(values) {
+  return values.map((value) => trimOutput(value)).find(Boolean) ?? '';
+}
+
+function quoteDetail(label, value) {
+  return value ? `${label}: ${value}` : null;
+}
+
+function looksLikePath(command) {
+  return /[\\/]/.test(command) || path.isAbsolute(command);
+}
+
+function dedupe(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+export function buildClaudeCodeCommandCandidates(command = 'claude', { platform = process.platform } = {}) {
+  const candidates = [command];
+  if (platform === 'win32' && !looksLikePath(command) && !command.toLowerCase().endsWith('.cmd')) {
+    candidates.push(`${command}.cmd`);
+  }
+  return dedupe(candidates);
+}
+
+export function runCapturedCommand(command, args, {
+  spawnSyncImpl = spawnSync,
+  env = process.env,
+} = {}) {
+  return normalizeProcessResult(spawnSyncImpl(command, args, {
+    encoding: 'utf8',
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }));
+}
+
+export function resolveClaudeCodeCommand(command = 'claude', {
+  platform = process.platform,
+  spawnSyncImpl = spawnSync,
+  env = process.env,
+} = {}) {
+  const candidates = buildClaudeCodeCommandCandidates(command, { platform });
+
+  for (const candidate of candidates) {
+    if (looksLikePath(candidate)) {
+      return {
+        found: true,
+        command: candidate,
+        source: 'explicit',
+        tried: candidates,
+      };
+    }
+
+    const lookupCommand = platform === 'win32' ? 'where' : 'which';
+    const lookupResult = runCapturedCommand(lookupCommand, [candidate], {
+      spawnSyncImpl,
+      env,
+    });
+
+    if (lookupResult.status === 0) {
+      const resolvedPath = firstNonEmpty(lookupResult.stdout.split(/\r?\n/));
+      return {
+        found: true,
+        command: resolvedPath || candidate,
+        source: lookupCommand,
+        tried: candidates,
+      };
+    }
+  }
+
+  return {
+    found: false,
+    command: null,
+    source: null,
+    tried: candidates,
+  };
+}
+
+function detectClaudeCodeFailureKind({ versionProbe, listProbe, addResult }) {
+  const errorCode = addResult.error?.code ?? listProbe.error?.code ?? versionProbe.error?.code ?? null;
+  const combinedOutput = [
+    versionProbe.stderr,
+    listProbe.stderr,
+    listProbe.stdout,
+    addResult.stderr,
+    addResult.stdout,
+  ].join('\n').toLowerCase();
+
+  if (errorCode === 'ENOENT') {
+    return 'cli-missing';
+  }
+
+  if (versionProbe.status !== 0) {
+    return 'cli-not-runnable';
+  }
+
+  if (
+    combinedOutput.includes('unknown command')
+    || combinedOutput.includes('command not found')
+    || combinedOutput.includes('invalid choice')
+    || combinedOutput.includes('no such command')
+  ) {
+    return 'mcp-subcommand-missing';
+  }
+
+  if (listProbe.status !== 0) {
+    return 'mcp-list-failed';
+  }
+
+  return 'registration-failed';
+}
+
+export function classifyClaudeCodeResult({
+  attemptedCommand,
+  addArgs,
+  versionProbe,
+  listProbe,
+  addResult,
+}) {
+  const manualCommand = formatShellCommand(attemptedCommand, addArgs);
+
+  if (addResult.status === 0) {
+    return {
+      key: 'claude-code',
+      client: 'Claude Code',
+      status: 'ok',
+      message: `Claude Code registered via ${manualCommand}`,
+      next: null,
+    };
+  }
+
+  const kind = detectClaudeCodeFailureKind({ versionProbe, listProbe, addResult });
+  const summaryOutput = firstNonEmpty([
+    addResult.stderr,
+    addResult.stdout,
+    listProbe.stderr,
+    listProbe.stdout,
+    versionProbe.stderr,
+    versionProbe.stdout,
+  ]);
+  const details = [
+    versionProbe.status === 0
+      ? quoteDetail('CLI', firstNonEmpty([versionProbe.stdout, 'ok']))
+      : quoteDetail('CLI probe', versionProbe.error?.message ?? `codigo ${versionProbe.status ?? 'unknown'}`),
+    listProbe.status === 0
+      ? quoteDetail('MCP list', 'ok')
+      : quoteDetail('MCP list', listProbe.error?.message ?? `codigo ${listProbe.status ?? 'unknown'}`),
+    addResult.error
+      ? quoteDetail('Add error', addResult.error.message)
+      : quoteDetail('Add exit', String(addResult.status ?? 'unknown')),
+    summaryOutput ? quoteDetail('Detalhe', summaryOutput) : null,
+  ].filter(Boolean);
+
+  let message;
+  if (kind === 'cli-missing') {
+    message = `Claude Code CLI nao encontrado. Registro manual pendente: ${manualCommand}`;
+  } else if (kind === 'cli-not-runnable') {
+    message = `Claude Code CLI encontrado, mas nao executou corretamente. ${details.join(' | ')}`;
+  } else if (kind === 'mcp-subcommand-missing') {
+    message = `Claude Code CLI encontrado, mas o subcomando MCP nao respondeu como esperado. ${details.join(' | ')}`;
+  } else if (kind === 'mcp-list-failed') {
+    message = `Claude Code CLI encontrado, mas 'claude mcp list' falhou antes do registro. ${details.join(' | ')}`;
+  } else {
+    message = `Claude Code CLI encontrado, mas o registro falhou. ${details.join(' | ')}`;
+  }
+
+  return {
+    key: 'claude-code',
+    client: 'Claude Code',
+    status: 'warning',
+    message,
+    next: `Execute manualmente: ${manualCommand}`,
+    diagnostic: kind,
+  };
+}
+
+export function determineRegistrationExitCode(results, {
+  applyAll = false,
+  selectedClients = [],
+} = {}) {
+  if (results.some((result) => result.status === 'fatal')) {
+    return OPERATION_EXIT_CODES.fatal;
+  }
+
+  if (results.some((result) => result.status === 'error')) {
+    return OPERATION_EXIT_CODES.error;
+  }
+
+  const warnings = results.filter((result) => result.status === 'warning');
+  if (!warnings.length) {
+    return OPERATION_EXIT_CODES.ok;
+  }
+
+  const onlyClaudeCodeSelected = selectedClients.length === 1 && selectedClients[0] === 'claude-code';
+  if (onlyClaudeCodeSelected) {
+    return OPERATION_EXIT_CODES.error;
+  }
+
+  const warningKeys = new Set(warnings.map((result) => result.key));
+  const successCount = results.filter((result) => result.status === 'ok').length;
+
+  if (applyAll && successCount > 0 && warningKeys.size === 1 && warningKeys.has('claude-code')) {
+    return OPERATION_EXIT_CODES.warning;
+  }
+
+  return OPERATION_EXIT_CODES.error;
+}
+
+export function summarizeRegistrationResults(results, exitCode) {
+  const next = results.map((result) => result.next).find(Boolean) ?? 'reinicie os clientes MCP apos o registro';
+
+  return {
+    result: exitCode === OPERATION_EXIT_CODES.ok
+      ? 'ok'
+      : exitCode === OPERATION_EXIT_CODES.warning
+        ? 'warning'
+        : 'error',
+    applied: results.filter((result) => result.status === 'ok').length,
+    warnings: results.filter((result) => result.status === 'warning').length,
+    failed: results.filter((result) => result.status === 'error' || result.status === 'fatal').length,
+    next,
+  };
+}