@fprad0/skill-master-mcp 0.0.8 → 0.0.10

package/bin/skill-master-bootstrap-global.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const rootDir = dirname(here);
+const args = process.argv.slice(2);
+
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`Skill Master global bootstrap
+
+Uso:
+  skill-master-bootstrap-global
+
+Instala as skills globais embutidas e registra o MCP skill_master em Codex,
+Claude Desktop, Gemini e Antigravity usando o binario global skill-master-mcp.
+Reinicie os clientes depois da execucao.
+`);
+  process.exit(0);
+}
+
+const steps = [
+  {
+    label: 'install-global-skills',
+    command: process.execPath,
+    args: [join(rootDir, 'bin', 'skill-master-install-global-skills.mjs'), '--overwrite'],
+  },
+  {
+    label: 'register-clients',
+    command: process.execPath,
+    args: [join(rootDir, 'bin', 'skill-master-register-clients.mjs'), '--apply-all', '--force'],
+  },
+];
+
+for (const step of steps) {
+  console.log(`[skill_master] Running ${step.label}...`);
+  const result = spawnSync(step.command, step.args, { stdio: 'inherit' });
+  if (result.status !== 0) {
+    process.exitCode = result.status ?? 1;
+    break;
+  }
+}
+
+if ((process.exitCode ?? 0) === 0) {
+  console.log('[skill_master] Global bootstrap complete.');
+}

package/bin/skill-master-doctor.mjs

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(here, '..');
+const args = process.argv.slice(2);
+const has = (flag) => args.includes(flag);
+
+if (has('--help') || has('-h')) {
+  console.log(`Skill Master Doctor
+
+Uso:
+  skill-master-doctor
+  skill-master-doctor --strict
+
+Valida pacote, binarios, skills globais e registro MCP em Codex, Claude,
+Gemini e Antigravity. Nao publica versoes e nao altera configuracoes.
+`);
+  process.exit(0);
+}
+
+const REQUIRED_GLOBAL_SKILLS = [
+  'catholic-moral-discernment',
+  'ai-ethics-human-dignity',
+  'professional-boundary-triage',
+  'broad-domain-router',
+  'language-quality-pt-en-fr',
+  'math-science-reasoning',
+  'philosophy-sociology-discernment',
+  'engineering-systems-master',
+  'source-authority-reviewer',
+  'release-ethics-gate',
+  'mcp-client-readiness',
+  'terminal-menu-operations',
+  'terminal-pixel-art-tui',
+];
+
+const REQUIRED_BINS = [
+  'skill-master-menu',
+  'skill-master-mcp',
+  'skill-master-update',
+  'skill-master-bootstrap-global',
+  'skill-master-install-global-skills',
+  'skill-master-register-clients',
+  'skill-master-doctor',
+];
+
+function defaultClaudeConfigPath() {
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+  }
+
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  }
+
+  return path.join(os.homedir(), '.config', 'Claude', 'claude_desktop_config.json');
+}
+
+function readJson(filePath) {
+  if (!existsSync(filePath)) return null;
+  try {
+    const raw = readFileSync(filePath, 'utf8').trim();
+    return raw ? JSON.parse(raw) : {};
+  } catch {
+    return null;
+  }
+}
+
+function commandExists(command) {
+  const lookup = process.platform === 'win32' ? 'where' : 'command';
+  const lookupArgs = process.platform === 'win32' ? [command] : ['-v', command];
+  const result = spawnSync(lookup, lookupArgs, { shell: process.platform !== 'win32', stdio: 'ignore' });
+  return result.status === 0;
+}
+
+function jsonClientState(filePath) {
+  const parsed = readJson(filePath);
+  const server = parsed?.mcpServers?.skill_master;
+  return {
+    filePath,
+    present: Boolean(parsed),
+    configured: server?.command === 'skill-master-mcp',
+    command: server?.command ?? null,
+  };
+}
+
+function codexState(filePath) {
+  if (!existsSync(filePath)) {
+    return { filePath, present: false, configured: false, command: null };
+  }
+
+  const content = readFileSync(filePath, 'utf8');
+  return {
+    filePath,
+    present: true,
+    configured: content.includes('[mcp_servers.skill_master]') && content.includes('command = "skill-master-mcp"'),
+    command: content.includes('skill-master-mcp') ? 'skill-master-mcp' : null,
+  };
+}
+
+function resultLine(ok, label, detail) {
+  const marker = ok ? 'OK' : 'NO';
+  return `[${marker}] ${label}${detail ? ` - ${detail}` : ''}`;
+}
+
+const packageJson = readJson(path.join(rootDir, 'package.json'));
+const globalSkillsRoot = path.join(process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'), 'skills');
+const installedSkills = REQUIRED_GLOBAL_SKILLS.filter((skill) => existsSync(path.join(globalSkillsRoot, skill, 'SKILL.md')));
+const missingSkills = REQUIRED_GLOBAL_SKILLS.filter((skill) => !installedSkills.includes(skill));
+
+const clients = [
+  ['Codex', codexState(path.join(process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'), 'config.toml'))],
+  ['Claude Desktop', jsonClientState(defaultClaudeConfigPath())],
+  ['Gemini CLI', jsonClientState(path.join(os.homedir(), '.gemini', 'settings.json'))],
+  ['Antigravity', jsonClientState(path.join(os.homedir(), '.gemini', 'config', 'mcp_config.json'))],
+];
+
+const binResults = REQUIRED_BINS.map((bin) => [bin, commandExists(bin)]);
+const allBinsOk = binResults.every(([, ok]) => ok);
+const allSkillsOk = missingSkills.length === 0;
+const allClientsOk = clients.every(([, state]) => state.configured);
+const packageOk = packageJson?.name === '@fprad0/skill-master-mcp';
+
+console.log('Skill Master Doctor');
+console.log(`- Root: ${rootDir}`);
+console.log(`- Package: ${packageJson?.name ?? 'unknown'}@${packageJson?.version ?? 'unknown'}`);
+console.log('');
+
+console.log(resultLine(packageOk, 'Pacote local reconhecido', packageOk ? packageJson.version : 'package.json inesperado'));
+console.log(resultLine(allBinsOk, 'Binarios globais no PATH', binResults.filter(([, ok]) => !ok).map(([bin]) => bin).join(', ') || 'todos encontrados'));
+for (const [bin, ok] of binResults) {
+  console.log(`  ${resultLine(ok, bin)}`);
+}
+
+console.log('');
+console.log(resultLine(allSkillsOk, `Skills globais ${installedSkills.length}/${REQUIRED_GLOBAL_SKILLS.length}`, missingSkills.join(', ') || 'todas instaladas'));
+console.log(`- Skills root: ${globalSkillsRoot}`);
+
+console.log('');
+for (const [name, state] of clients) {
+  const detail = state.configured
+    ? state.filePath
+    : state.present
+      ? `presente, mas command=${state.command ?? 'nao encontrado'} em ${state.filePath}`
+      : `ausente em ${state.filePath}`;
+  console.log(resultLine(state.configured, `${name} configurado`, detail));
+}
+
+const ready = packageOk && allBinsOk && allSkillsOk && allClientsOk;
+console.log('');
+console.log(resultLine(ready, 'Readiness global', ready ? 'pronto' : 'requer acao'));
+
+if (!ready) {
+  console.log('');
+  console.log('Proximo comando recomendado:');
+  console.log('  skill-master-menu --run bootstrap-global --yes');
+  console.log('');
+  console.log('Depois reinicie Codex, Claude, Gemini e Antigravity.');
+}
+
+if (has('--strict') && !ready) {
+  process.exitCode = 1;
+}

package/bin/skill-master-install-global-skills.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import { existsSync, readdirSync, cpSync, mkdirSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(here, '..');
+const defaultSource = path.join(rootDir, 'docs', 'skill-candidates');
+const defaultTarget = path.join(process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'), 'skills');
+
+const args = process.argv.slice(2);
+const has = (flag) => args.includes(flag);
+const readValue = (flag, fallback) => {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : fallback;
+};
+
+if (has('--help')) {
+  console.log(`Skill Master global skills installer
+
+Uso:
+  skill-master-install-global-skills
+  skill-master-install-global-skills --overwrite
+  skill-master-install-global-skills --dry-run
+  skill-master-install-global-skills --target ~/.codex/skills
+  skill-master-install-global-skills --source ./docs/skill-candidates/v0.0.10
+
+Instala as skills globais embutidas em CODEX_HOME/skills ou ~/.codex/skills.
+Quando --source aponta para docs/skill-candidates, todas as pastas versionadas v*
+sao lidas.
+`);
+  process.exit(0);
+}
+
+const source = readValue('--source', defaultSource);
+const target = readValue('--target', defaultTarget);
+const overwrite = has('--overwrite');
+const dryRun = has('--dry-run');
+
+if (!existsSync(source)) {
+  console.error(`[skill_master] Source not found: ${source}`);
+  process.exit(1);
+}
+
+const listSkillSources = (sourcePath) => {
+  const entries = readdirSync(sourcePath, { withFileTypes: true });
+  const directSkills = entries
+    .filter((entry) => entry.isDirectory() && existsSync(path.join(sourcePath, entry.name, 'SKILL.md')))
+    .map((entry) => ({ name: entry.name, path: path.join(sourcePath, entry.name) }));
+
+  if (directSkills.length) {
+    return directSkills;
+  }
+
+  return entries
+    .filter((entry) => entry.isDirectory())
+    .flatMap((entry) => {
+      const versionPath = path.join(sourcePath, entry.name);
+      return readdirSync(versionPath, { withFileTypes: true })
+        .filter((skillEntry) => skillEntry.isDirectory() && existsSync(path.join(versionPath, skillEntry.name, 'SKILL.md')))
+        .map((skillEntry) => ({ name: skillEntry.name, path: path.join(versionPath, skillEntry.name) }));
+    })
+    .sort((left, right) => left.name.localeCompare(right.name));
+};
+
+const skills = listSkillSources(source);
+
+if (!dryRun) {
+  mkdirSync(target, { recursive: true });
+}
+
+const installed = [];
+const skipped = [];
+
+for (const skill of skills) {
+  const from = skill.path;
+  const to = path.join(target, skill.name);
+  if (existsSync(to) && !overwrite) {
+    skipped.push(skill.name);
+    continue;
+  }
+  if (!dryRun) {
+    cpSync(from, to, { recursive: true, force: overwrite });
+  }
+  installed.push(skill.name);
+}
+
+console.log('[skill_master] Global skills installer');
+console.log(`- Source: ${source}`);
+console.log(`- Target: ${target}`);
+console.log(`- Installed: ${installed.length}`);
+console.log(`- Skipped: ${skipped.length}`);
+if (dryRun) console.log('- Dry run: no files were written.');
+if (installed.length) console.log(`- Installed skills: ${installed.join(', ')}`);
+if (skipped.length) console.log(`- Skipped skills: ${skipped.join(', ')}`);
+console.log('[skill_master] Restart or rescan Codex to load new global skills.');

package/bin/skill-master-menu.mjs

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
 
 import prompts from 'prompts';
+import readline from 'node:readline';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import {
-  buildMenuChoices,
   buildMenuCommands,
   formatActionHeader,
+  formatCyberMenuFrame,
   formatHelp,
-  formatMenuBanner,
+  formatRunningActionFrame,
   formatResultMessage,
   formatStatusReport,
   getMenuStatus,
@@ -20,6 +21,19 @@ import {
 const currentFile = fileURLToPath(import.meta.url);
 const rootDir = dirname(dirname(currentFile));
 const commands = buildMenuCommands({ rootDir, currentFile });
+readline.emitKeypressEvents(process.stdin);
+const CONTROL = {
+  alternateScreenIn: '\x1b[?1049h',
+  alternateScreenOut: '\x1b[?1049l',
+  hideCursor: '\x1b[?25l',
+  showCursor: '\x1b[?25h',
+  cursorHome: '\x1b[H',
+  clearScreen: '\x1b[2J',
+  clearToEnd: '\x1b[0J',
+  reset: '\x1b[0m',
+  syncStart: '\x1b[?2026h',
+  syncEnd: '\x1b[?2026l',
+};
 
 function parseArgs(argv) {
   const parsed = {
@@ -62,6 +76,10 @@ function printStatus() {
 }
 
 async function runSelectedAction(action, { yes = false, useColor = false } = {}) {
+  if (action.disabledReason) {
+    throw new Error(`Action ${action.key} is unavailable here: ${action.disabledReason}`);
+  }
+
   if (action.confirmMessage && !yes) {
     if (!isInteractiveTerminal()) {
       throw new Error(`Action ${action.key} requires --yes outside an interactive terminal.`);
@@ -88,47 +106,177 @@ async function runSelectedAction(action, { yes = false, useColor = false } = {})
   return { cancelled: false, code };
 }
 
-async function runVisualMenu() {
-  while (true) {
-    console.clear();
-    const status = getMenuStatus(rootDir);
-    console.log(formatMenuBanner(status, { useColor: true }));
-    console.log('');
-
-    const selection = await prompts({
-      type: 'select',
-      name: 'action',
-      message: 'Escolha uma acao',
-      choices: buildMenuChoices(commands),
-      initial: 0,
-    });
+const readKey = () => new Promise((resolve) => {
+  process.stdin.once('keypress', (_str, key) => resolve(key));
+});
 
-    if (!selection.action || selection.action === '__exit__') {
-      return 0;
+function createKeyReader() {
+  const queue = [];
+  const waiters = [];
+  const onKeypress = (_str, key) => {
+    const waiter = waiters.shift();
+    if (waiter) {
+      clearTimeout(waiter.timer);
+      waiter.resolve(key);
+      return;
     }
+    queue.push(key);
+  };
 
-    const action = commands.find((entry) => entry.key === selection.action);
-    if (!action) {
-      return 1;
-    }
+  process.stdin.on('keypress', onKeypress);
 
-    const result = await runSelectedAction(action, { useColor: true });
-    if (result.cancelled) {
-      continue;
-    }
+  return {
+    read(timeoutMs) {
+      if (queue.length) return Promise.resolve(queue.shift());
+      return new Promise((resolve) => {
+        const waiter = {
+          resolve,
+          timer: setTimeout(() => {
+            const index = waiters.indexOf(waiter);
+            if (index >= 0) waiters.splice(index, 1);
+            resolve(null);
+          }, timeoutMs),
+        };
+        waiters.push(waiter);
+      });
+    },
+    close() {
+      for (const waiter of waiters.splice(0)) {
+        clearTimeout(waiter.timer);
+        waiter.resolve(null);
+      }
+      process.stdin.off('keypress', onKeypress);
+    },
+  };
+}
 
-    const nextStep = await prompts({
-      type: 'toggle',
-      name: 'keepGoing',
-      message: 'Voltar ao menu?',
-      initial: true,
-      active: 'sim',
-      inactive: 'nao',
-    });
+function setRawInput(enabled) {
+  if (typeof process.stdin.setRawMode === 'function') {
+    process.stdin.setRawMode(enabled);
+  }
+  if (enabled) process.stdin.resume();
+}
+
+function restoreMenuInput() {
+  setRawInput(true);
+  process.stdin.resume();
+}
+
+function enterVisualScreen() {
+  process.stdout.write(`${CONTROL.alternateScreenIn}${CONTROL.hideCursor}${CONTROL.clearScreen}${CONTROL.cursorHome}`);
+}
+
+function leaveVisualScreen() {
+  process.stdout.write(`${CONTROL.reset}${CONTROL.showCursor}${CONTROL.alternateScreenOut}`);
+}
+
+function writeStableFrame(frame, { clear = false } = {}) {
+  const prefix = clear ? CONTROL.clearScreen : '';
+  process.stdout.write([
+    CONTROL.syncStart,
+    CONTROL.cursorHome,
+    prefix,
+    frame,
+    '\n',
+    CONTROL.clearToEnd,
+    CONTROL.syncEnd,
+  ].join(''));
+}
+
+function renderCyberMenu(selectedIndex, tick, { clear = false } = {}) {
+  const status = getMenuStatus(rootDir);
+  const frame = formatCyberMenuFrame(status, commands, selectedIndex, tick, {
+    columns: process.stdout.columns ?? 120,
+    rows: process.stdout.rows ?? 32,
+    useColor: true,
+  });
+  writeStableFrame(frame, { clear });
+}
+
+function renderRunningAction(action, tick) {
+  const status = getMenuStatus(rootDir);
+  const frame = formatRunningActionFrame(status, action, tick, {
+    columns: process.stdout.columns ?? 120,
+    rows: process.stdout.rows ?? 32,
+    useColor: true,
+  });
+  writeStableFrame(frame, { clear: true });
+}
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitForAnyKey(message = 'Pressione qualquer tecla para voltar ao menu...') {
+  process.stdout.write(`\n${message}`);
+  setRawInput(true);
+  await readKey();
+  setRawInput(false);
+}
+
+async function runVisualMenu() {
+  let selectedIndex = 0;
+  let tick = 0;
+  let lastCode = 0;
+  let keyReader = createKeyReader();
+  let previousColumns = process.stdout.columns ?? 120;
+  let previousRows = process.stdout.rows ?? 32;
+  let needsClear = true;
+
+  enterVisualScreen();
+  restoreMenuInput();
+
+  try {
+    while (true) {
+      const columns = process.stdout.columns ?? 120;
+      const rows = process.stdout.rows ?? 32;
+      const resized = columns !== previousColumns || rows !== previousRows;
+      previousColumns = columns;
+      previousRows = rows;
+      renderCyberMenu(selectedIndex, tick, { clear: needsClear || resized });
+      needsClear = false;
+      const key = await keyReader.read(240);
+
+      if (!key) {
+        tick += 1;
+        continue;
+      }
 
-    if (!nextStep.keepGoing) {
-      return result.code;
+      if (key.ctrl && key.name === 'c') return 130;
+      if (key.name === 'escape' || key.name === 'q') return lastCode;
+      if (key.name === 'up' || key.name === 'k') {
+        selectedIndex = selectedIndex === 0 ? commands.length - 1 : selectedIndex - 1;
+        continue;
+      }
+      if (key.name === 'down' || key.name === 'j') {
+        selectedIndex = selectedIndex === commands.length - 1 ? 0 : selectedIndex + 1;
+        continue;
+      }
+      if (key.name === 'return' || key.name === 'enter') {
+        const action = commands[selectedIndex];
+        keyReader.close();
+        renderRunningAction(action, tick);
+        await sleep(180);
+        setRawInput(false);
+        leaveVisualScreen();
+        try {
+          const result = await runSelectedAction(action, { useColor: true });
+          lastCode = result.code;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          process.stderr.write(`[skill_master] ${message}\n`);
+          lastCode = 1;
+        }
+        await waitForAnyKey();
+        keyReader = createKeyReader();
+        restoreMenuInput();
+        enterVisualScreen();
+        needsClear = true;
+      }
     }
+  } finally {
+    keyReader.close();
+    setRawInput(false);
+    process.stdin.pause();
+    leaveVisualScreen();
   }
 }