@fprad0/skill-master-mcp 0.0.11 → 0.0.12

package/bin/lib/skill-installation.mjs

@@ -0,0 +1,215 @@
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+} from 'node:fs';
+import path from 'node:path';
+
+export const DEFAULT_PROJECT_SKILL_ROOTS = [
+  '.agents/skills',
+  '.codex/skills',
+  '.claude/skills',
+  '.gemini/skills',
+];
+
+export function 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.sort((left, right) => left.name.localeCompare(right.name));
+  }
+
+  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));
+}
+
+export function parseRootList(value) {
+  return String(value ?? '')
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+export function normalizeProjectSkillRoots(projectRoot, roots = DEFAULT_PROJECT_SKILL_ROOTS) {
+  const uniqueRoots = Array.from(new Set(roots.map((root) => {
+    const normalized = root.replace(/\\/g, '/');
+    return path.isAbsolute(normalized) ? normalized : normalized.replace(/^\.\//, '');
+  })));
+  return uniqueRoots.map((root) => ({
+    relative: root,
+    absolute: path.isAbsolute(root) ? root : path.resolve(projectRoot, root),
+  }));
+}
+
+export function installSkillsToTarget({ skills, target, overwrite = false, dryRun = false }) {
+  if (!dryRun) {
+    mkdirSync(target, { recursive: true });
+  }
+
+  const installed = [];
+  const skipped = [];
+
+  for (const skill of skills) {
+    const destination = path.join(target, skill.name);
+    if (existsSync(destination) && !overwrite) {
+      skipped.push(skill.name);
+      continue;
+    }
+
+    if (!dryRun) {
+      cpSync(skill.path, destination, { recursive: true, force: overwrite });
+    }
+    installed.push(skill.name);
+  }
+
+  return { target, installed, skipped };
+}
+
+export function buildProjectSkillCatalog({
+  projectRoot,
+  skillRoots,
+  skills,
+  packageName,
+  packageVersion,
+}) {
+  return {
+    schemaVersion: 1,
+    generatedAt: new Date().toISOString(),
+    packageName,
+    packageVersion,
+    projectRoot,
+    skillRoots: skillRoots.map((root) => root.relative),
+    skillCount: Array.from(new Set(skills.map((skill) => skill.name))).length,
+    skills: Array.from(new Set(skills.map((skill) => skill.name))).sort(),
+  };
+}
+
+export function writeProjectSkillCatalog({ projectRoot, catalog, catalogPath = '.skill-master/catalog.json', dryRun = false }) {
+  const absolutePath = path.isAbsolute(catalogPath)
+    ? catalogPath
+    : path.resolve(projectRoot, catalogPath);
+
+  if (!dryRun) {
+    mkdirSync(path.dirname(absolutePath), { recursive: true });
+    writeFileSync(absolutePath, `${JSON.stringify(catalog, null, 2)}\n`, 'utf8');
+  }
+
+  return absolutePath;
+}
+
+export function syncProjectPackageJson({
+  projectRoot,
+  skillRoots,
+  catalogPath = '.skill-master/catalog.json',
+  packageName,
+  packageVersion,
+  createIfMissing = false,
+  dryRun = false,
+}) {
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  const packageJsonExists = existsSync(packageJsonPath);
+
+  if (!packageJsonExists && !createIfMissing) {
+    return { path: packageJsonPath, status: 'missing' };
+  }
+
+  const current = packageJsonExists
+    ? JSON.parse(readFileSync(packageJsonPath, 'utf8'))
+    : { private: true };
+
+  const scripts = current.scripts && typeof current.scripts === 'object' ? current.scripts : {};
+  const installScript = 'skill-master-install-project-skills --sync-package-json';
+
+  const next = {
+    ...current,
+    scripts: {
+      ...scripts,
+      'skill-master:install-project-skills': scripts['skill-master:install-project-skills'] ?? installScript,
+    },
+    skillMaster: {
+      ...(current.skillMaster && typeof current.skillMaster === 'object' ? current.skillMaster : {}),
+      package: packageName,
+      packageVersion,
+      projectSkillRoots: skillRoots.map((root) => root.relative),
+      projectSkillCatalog: catalogPath,
+      installCommand: installScript,
+    },
+  };
+
+  if (!dryRun) {
+    writeFileSync(packageJsonPath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+  }
+
+  if (dryRun) {
+    return { path: packageJsonPath, status: packageJsonExists ? 'would-update' : 'would-create' };
+  }
+
+  return { path: packageJsonPath, status: packageJsonExists ? 'updated' : 'created' };
+}
+
+export function installProjectSkills({
+  source,
+  projectRoot,
+  roots = DEFAULT_PROJECT_SKILL_ROOTS,
+  overwrite = false,
+  dryRun = false,
+  writeCatalog = true,
+  syncPackageJson = true,
+  createPackageJson = false,
+  catalogPath = '.skill-master/catalog.json',
+  packageName,
+  packageVersion,
+}) {
+  const skills = listSkillSources(source);
+  const skillRoots = normalizeProjectSkillRoots(projectRoot, roots);
+  const targets = skillRoots.map((root) => installSkillsToTarget({
+    skills,
+    target: root.absolute,
+    overwrite,
+    dryRun,
+  }));
+  const catalog = buildProjectSkillCatalog({
+    projectRoot,
+    skillRoots,
+    skills,
+    packageName,
+    packageVersion,
+  });
+  const writtenCatalogPath = writeCatalog
+    ? writeProjectSkillCatalog({ projectRoot, catalog, catalogPath, dryRun })
+    : null;
+  const packageJson = syncPackageJson
+    ? syncProjectPackageJson({
+      projectRoot,
+      skillRoots,
+      catalogPath,
+      packageName,
+      packageVersion,
+      createIfMissing: createPackageJson,
+      dryRun,
+    })
+    : { path: path.join(projectRoot, 'package.json'), status: 'skipped' };
+
+  return {
+    source,
+    projectRoot,
+    roots: skillRoots,
+    skills,
+    targets,
+    catalogPath: writtenCatalogPath,
+    packageJson,
+  };
+}

package/bin/skill-master-doctor.mjs

@@ -23,7 +23,7 @@ Uso:
   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.
+Claude Code, Gemini e Antigravity. Nao publica versoes e nao altera configuracoes.
 
 O registro recomendado usa Node absoluto + bin/skill-master.mjs absoluto para
 evitar falhas de PATH em apps desktop no Windows, Linux e macOS.
@@ -45,6 +45,18 @@ const REQUIRED_GLOBAL_SKILLS = [
   'mcp-client-readiness',
   'terminal-menu-operations',
   'terminal-pixel-art-tui',
+  'senior-master-code-optimizer',
+  'typescript-senior-master-engineering',
+  'python-senior-master-engineering',
+  'javascript-senior-master-engineering',
+  'go-senior-master-engineering',
+  'sql-senior-master-engineering',
+  'json-senior-master-engineering',
+  'ruby-senior-master-engineering',
+  'react-senior-master-engineering',
+  'html-senior-master-engineering',
+  'css-senior-master-engineering',
+  'csharp-senior-master-engineering',
 ];
 
 const REQUIRED_BINS = [
@@ -53,6 +65,7 @@ const REQUIRED_BINS = [
   'skill-master-update',
   'skill-master-bootstrap-global',
   'skill-master-install-global-skills',
+  'skill-master-install-project-skills',
   'skill-master-register-clients',
   'skill-master-doctor',
 ];
@@ -74,6 +87,35 @@ function commandExists(command) {
   return result.status === 0;
 }
 
+function claudeCodeState() {
+  if (!commandExists('claude')) {
+    return {
+      filePath: 'claude CLI',
+      present: false,
+      configured: true,
+      optionalMissing: true,
+      mode: 'cli-missing',
+      command: null,
+    };
+  }
+
+  const result = spawnSync('claude', ['mcp', 'list'], {
+    encoding: 'utf8',
+    timeout: 10000,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  const output = `${result.stdout ?? ''}${result.stderr ?? ''}`;
+  const configured = /skill[-_]master/i.test(output);
+
+  return {
+    filePath: 'claude mcp list',
+    present: true,
+    configured,
+    mode: configured ? 'claude-cli' : result.status === 0 ? 'missing' : 'list-failed',
+    command: configured ? 'claude mcp list' : output.trim() || null,
+  };
+}
+
 function jsonClientState(filePath) {
   const parsed = readJson(filePath);
   if (parsed.invalid) {
@@ -128,6 +170,7 @@ const clientPaths = defaultClientConfigPaths();
 const clients = [
   ['Codex', codexState(clientPaths.codex)],
   ['Claude Desktop', jsonClientState(clientPaths.claude)],
+  ['Claude Code', claudeCodeState()],
   ['Gemini CLI', jsonClientState(clientPaths.gemini)],
   ['Antigravity', jsonClientState(clientPaths.antigravity)],
 ];
@@ -155,12 +198,15 @@ console.log(`- Skills root: ${globalSkillsRoot}`);
 
 console.log('');
 for (const [name, state] of clients) {
+  const label = state.optionalMissing ? `${name} opcional` : `${name} configurado`;
   const detail = state.configured
-    ? `${state.mode} em ${state.filePath}`
+    ? state.optionalMissing
+      ? `CLI nao encontrado; pule se voce nao usa Claude Code neste computador`
+      : `${state.mode} em ${state.filePath}`
     : state.present
       ? `presente, mas mode=${state.mode} command=${state.command ?? 'nao encontrado'} em ${state.filePath}`
       : `ausente em ${state.filePath}`;
-  console.log(resultLine(state.configured, `${name} configurado`, detail));
+  console.log(resultLine(state.configured, label, detail));
 }
 
 const ready = packageOk && allBinsOk && allSkillsOk && allClientsOk;
@@ -171,9 +217,10 @@ if (!ready) {
   console.log('');
   console.log('Proximo comando recomendado:');
   console.log('  skill-master-register-clients --apply-all --force');
+  console.log('  skill-master-register-clients --apply-claude-code --claude-code-scope user');
   console.log('  skill-master-menu --run bootstrap-global --yes');
   console.log('');
-  console.log('Depois reinicie Codex, Claude, Gemini e Antigravity.');
+  console.log('Depois reinicie Codex, Claude Desktop, Claude Code, Gemini e Antigravity.');
 }
 
 if (has('--strict') && !ready) {

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

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { existsSync, readdirSync, cpSync, mkdirSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { installSkillsToTarget, listSkillSources } from './lib/skill-installation.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = path.resolve(here, '..');
@@ -43,48 +44,9 @@ if (!existsSync(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);
-}
+const { installed, skipped } = installSkillsToTarget({ skills, target, overwrite, dryRun });
 
 console.log('[skill_master] Global skills installer');
 console.log(`- Source: ${source}`);

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

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  DEFAULT_PROJECT_SKILL_ROOTS,
+  installProjectSkills,
+  parseRootList,
+} from './lib/skill-installation.mjs';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(here, '..');
+const defaultSource = path.join(rootDir, 'docs', 'skill-candidates');
+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;
+};
+const readValues = (flag) => args.flatMap((arg, index) => arg === flag ? [args[index + 1]] : []).filter(Boolean);
+
+if (has('--help') || has('-h')) {
+  console.log(`Skill Master project skills installer
+
+Uso:
+  skill-master-install-project-skills
+  skill-master-install-project-skills --project-root .
+  skill-master-install-project-skills --sync-package-json
+  skill-master-install-project-skills --roots ".agents/skills,.codex/skills,.claude/skills,.gemini/skills"
+  skill-master-install-project-skills --root .custom/skills --root .codex/skills
+  skill-master-install-project-skills --overwrite
+  skill-master-install-project-skills --dry-run
+
+Instala as skills embutidas em roots de projeto para agentes e clientes locais.
+Por padrao usa o diretorio atual como projeto e as roots:
+  ${DEFAULT_PROJECT_SKILL_ROOTS.join(', ')}
+
+Tambem escreve .skill-master/catalog.json. Quando --sync-package-json e usado,
+registra scripts e metadados em package.json sem alterar package-lock.json
+manualmente; para projetos npm, rode npm install --package-lock-only se quiser
+materializar o lock do proprio projeto.
+`);
+  process.exit(0);
+}
+
+const packageJson = JSON.parse(readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
+const source = readValue('--source', defaultSource);
+const projectRoot = path.resolve(readValue('--project-root', process.cwd()));
+const explicitRoots = readValues('--root');
+const csvRoots = parseRootList(readValue('--roots', ''));
+const roots = explicitRoots.length ? explicitRoots : csvRoots.length ? csvRoots : DEFAULT_PROJECT_SKILL_ROOTS;
+const overwrite = has('--overwrite');
+const dryRun = has('--dry-run');
+const writeCatalog = !has('--no-catalog');
+const syncPackageJson = has('--sync-package-json') || (!has('--no-package-json') && existsSync(path.join(projectRoot, 'package.json')));
+const createPackageJson = has('--create-package-json');
+const catalogPath = readValue('--catalog-path', '.skill-master/catalog.json');
+
+if (!existsSync(source)) {
+  console.error(`[skill_master] Source not found: ${source}`);
+  process.exit(1);
+}
+
+if (!existsSync(projectRoot)) {
+  console.error(`[skill_master] Project root not found: ${projectRoot}`);
+  process.exit(1);
+}
+
+const result = installProjectSkills({
+  source,
+  projectRoot,
+  roots,
+  overwrite,
+  dryRun,
+  writeCatalog,
+  syncPackageJson,
+  createPackageJson,
+  catalogPath,
+  packageName: packageJson.name,
+  packageVersion: packageJson.version,
+});
+
+const uniqueSkillCount = new Set(result.skills.map((skill) => skill.name)).size;
+
+console.log('[skill_master] Project skills installer');
+console.log(`- Source: ${source}`);
+console.log(`- Project: ${projectRoot}`);
+console.log(`- Skill roots: ${result.roots.map((root) => root.relative).join(', ')}`);
+console.log(`- Skills cataloged: ${uniqueSkillCount}`);
+for (const target of result.targets) {
+  console.log(`- Target ${target.target}: installed ${target.installed.length}, skipped ${target.skipped.length}`);
+}
+if (result.catalogPath) console.log(`- Catalog: ${result.catalogPath}`);
+console.log(`- package.json: ${result.packageJson.status} (${result.packageJson.path})`);
+if (dryRun) console.log('- Dry run: no files were written.');
+console.log('[skill_master] Restart or rescan the MCP client so project-local skills can be discovered.');

package/bin/skill-master-menu.mjs

@@ -7,10 +7,12 @@ import { fileURLToPath } from 'node:url';
 import {
   buildMenuCommands,
   formatActionHeader,
+  formatCyberConfirmFrame,
   formatCyberMenuFrame,
   formatHelp,
   formatRunningActionFrame,
   formatResultMessage,
+  formatSkillMasterIntroFrame,
   formatStatusReport,
   getMenuStatus,
   isInteractiveTerminal,
@@ -20,7 +22,8 @@ import {
 
 const currentFile = fileURLToPath(import.meta.url);
 const rootDir = dirname(dirname(currentFile));
-const commands = buildMenuCommands({ rootDir, currentFile });
+const invocationCwd = process.cwd();
+const commands = buildMenuCommands({ rootDir, currentFile, invocationCwd });
 readline.emitKeypressEvents(process.stdin);
 const CONTROL = {
   alternateScreenIn: '\x1b[?1049h',
@@ -100,7 +103,7 @@ async function runSelectedAction(action, { yes = false, useColor = false } = {})
   console.log('');
   console.log(formatActionHeader(action, { useColor }));
   console.log('');
-  const code = await runCommand(action, { cwd: rootDir });
+  const code = await runCommand(action, { cwd: action.cwd ?? rootDir });
   console.log('');
   console.log(formatResultMessage(code, { useColor }));
   return { cancelled: false, code };
@@ -183,6 +186,13 @@ function writeStableFrame(frame, { clear = false } = {}) {
   ].join(''));
 }
 
+function visualHudAllowed() {
+  return isInteractiveTerminal()
+    && process.env.SKILL_MASTER_NO_VISUAL !== '1'
+    && process.env.CI !== 'true'
+    && process.env.TERM !== 'dumb';
+}
+
 function renderCyberMenu(selectedIndex, tick, { clear = false } = {}) {
   const status = getMenuStatus(rootDir);
   const frame = formatCyberMenuFrame(status, commands, selectedIndex, tick, {
@@ -203,8 +213,65 @@ function renderRunningAction(action, tick) {
   writeStableFrame(frame, { clear: true });
 }
 
+function renderIntro(tick, message) {
+  const status = getMenuStatus(rootDir);
+  const frame = formatSkillMasterIntroFrame(status, tick, {
+    columns: process.stdout.columns ?? 120,
+    rows: process.stdout.rows ?? 32,
+    useColor: true,
+    message,
+  });
+  writeStableFrame(frame, { clear: tick === 0 });
+}
+
+function renderConfirmAction(action, tick) {
+  const status = getMenuStatus(rootDir);
+  const frame = formatCyberConfirmFrame(status, action, tick, {
+    columns: process.stdout.columns ?? 120,
+    rows: process.stdout.rows ?? 32,
+    useColor: true,
+  });
+  writeStableFrame(frame, { clear: tick === 0 });
+}
+
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+async function animateIntro(message = 'skill_master assumindo o workflow', frames = 6) {
+  for (let frame = 0; frame < frames; frame += 1) {
+    renderIntro(frame, message);
+    await sleep(70);
+  }
+}
+
+async function animateRunningAction(action, startTick) {
+  for (let frame = 0; frame < 5; frame += 1) {
+    renderRunningAction(action, startTick + frame);
+    await sleep(90);
+  }
+}
+
+async function confirmVisualAction(action, startTick) {
+  let tick = startTick;
+  const reader = createKeyReader();
+
+  try {
+    while (true) {
+      renderConfirmAction(action, tick);
+      const key = await reader.read(180);
+      if (!key) {
+        tick += 1;
+        continue;
+      }
+
+      if (key.ctrl && key.name === 'c') return { confirmed: false, code: 130 };
+      if (key.name === 'return' || key.name === 'enter' || key.name === 'y') return { confirmed: true, code: 0 };
+      if (key.name === 'escape' || key.name === 'q' || key.name === 'n') return { confirmed: false, code: 0 };
+    }
+  } finally {
+    reader.close();
+  }
+}
+
 async function waitForAnyKey(message = 'Pressione qualquer tecla para voltar ao menu...') {
   process.stdout.write(`\n${message}`);
   setRawInput(true);
@@ -225,6 +292,8 @@ async function runVisualMenu() {
   restoreMenuInput();
 
   try {
+    await animateIntro('skill_master online / carregando menu operacional', 7);
+
     while (true) {
       const columns = process.stdout.columns ?? 120;
       const rows = process.stdout.rows ?? 32;
@@ -233,7 +302,7 @@ async function runVisualMenu() {
       previousRows = rows;
       renderCyberMenu(selectedIndex, tick, { clear: needsClear || resized });
       needsClear = false;
-      const key = await keyReader.read(240);
+      const key = await keyReader.read(160);
 
       if (!key) {
         tick += 1;
@@ -253,12 +322,20 @@ async function runVisualMenu() {
       if (key.name === 'return' || key.name === 'enter') {
         const action = commands[selectedIndex];
         keyReader.close();
-        renderRunningAction(action, tick);
-        await sleep(180);
+        if (action.confirmMessage) {
+          const confirmation = await confirmVisualAction(action, tick);
+          if (confirmation.code === 130) return 130;
+          if (!confirmation.confirmed) {
+            keyReader = createKeyReader();
+            needsClear = true;
+            continue;
+          }
+        }
+        await animateRunningAction(action, tick);
         setRawInput(false);
         leaveVisualScreen();
         try {
-          const result = await runSelectedAction(action, { useColor: true });
+          const result = await runSelectedAction(action, { yes: Boolean(action.confirmMessage), useColor: true });
           lastCode = result.code;
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
@@ -300,6 +377,14 @@ async function main() {
     }
 
     const action = commands.find((entry) => entry.key === actionKey);
+    if (visualHudAllowed()) {
+      enterVisualScreen();
+      try {
+        await animateIntro(`skill_master executando ${action.label}`, 6);
+      } finally {
+        leaveVisualScreen();
+      }
+    }
     const result = await runSelectedAction(action, { yes: args.yes, useColor: isInteractiveTerminal() });
     return result.code;
   }