@fprad0/skill-master-mcp 0.0.10 → 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-bootstrap-global.mjs

@@ -15,7 +15,8 @@ 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.
+Claude Desktop, Gemini e Antigravity usando Node absoluto e o entrypoint
+absoluto do pacote, sem depender do PATH do app desktop.
 Reinicie os clientes depois da execucao.
 `);
   process.exit(0);

package/bin/skill-master-doctor.mjs

@@ -4,6 +4,11 @@ import { existsSync, readFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import {
+  assessCodexConfigContent,
+  assessMcpServerConfig,
+  defaultClientConfigPaths,
+} from './lib/client-config.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = path.resolve(here, '..');
@@ -18,7 +23,10 @@ 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.
 `);
   process.exit(0);
 }
@@ -37,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 = [
@@ -45,29 +65,18 @@ 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',
 ];
 
-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;
+  if (!existsSync(filePath)) return { present: false, invalid: false, value: null };
   try {
     const raw = readFileSync(filePath, 'utf8').trim();
-    return raw ? JSON.parse(raw) : {};
+    return { present: true, invalid: false, value: raw ? JSON.parse(raw) : {} };
   } catch {
-    return null;
+    return { present: true, invalid: true, value: null };
   }
 }
 
@@ -78,28 +87,71 @@ 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);
-  const server = parsed?.mcpServers?.skill_master;
+  if (parsed.invalid) {
+    return {
+      filePath,
+      present: true,
+      configured: false,
+      mode: 'invalid-json',
+      command: null,
+    };
+  }
+
+  const server = parsed.value?.mcpServers?.skill_master;
+  const assessment = assessMcpServerConfig(server);
   return {
     filePath,
-    present: Boolean(parsed),
-    configured: server?.command === 'skill-master-mcp',
-    command: server?.command ?? null,
+    present: parsed.present,
+    configured: assessment.robust,
+    mode: assessment.mode,
+    command: assessment.command,
   };
 }
 
 function codexState(filePath) {
   if (!existsSync(filePath)) {
-    return { filePath, present: false, configured: false, command: null };
+    return { filePath, present: false, configured: false, mode: 'missing', command: null };
   }
 
   const content = readFileSync(filePath, 'utf8');
+  const assessment = assessCodexConfigContent(content);
   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,
+    configured: assessment.robust,
+    mode: assessment.mode,
+    command: assessment.command,
   };
 }
 
@@ -108,16 +160,19 @@ function resultLine(ok, label, detail) {
   return `[${marker}] ${label}${detail ? ` - ${detail}` : ''}`;
 }
 
-const packageJson = readJson(path.join(rootDir, 'package.json'));
+const packageJsonState = readJson(path.join(rootDir, 'package.json'));
+const packageJson = packageJsonState.value;
 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 clientPaths = defaultClientConfigPaths();
 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'))],
+  ['Codex', codexState(clientPaths.codex)],
+  ['Claude Desktop', jsonClientState(clientPaths.claude)],
+  ['Claude Code', claudeCodeState()],
+  ['Gemini CLI', jsonClientState(clientPaths.gemini)],
+  ['Antigravity', jsonClientState(clientPaths.antigravity)],
 ];
 
 const binResults = REQUIRED_BINS.map((bin) => [bin, commandExists(bin)]);
@@ -143,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.filePath
+    ? state.optionalMissing
+      ? `CLI nao encontrado; pule se voce nao usa Claude Code neste computador`
+      : `${state.mode} em ${state.filePath}`
     : state.present
-      ? `presente, mas command=${state.command ?? 'nao encontrado'} em ${state.filePath}`
+      ? `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;
@@ -158,9 +216,11 @@ console.log(resultLine(ready, 'Readiness global', ready ? 'pronto' : 'requer aca
 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, '..');
@@ -24,7 +25,7 @@ Uso:
   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
+  skill-master-install-global-skills --source ./docs/skill-candidates/v0.0.11
 
 Instala as skills globais embutidas em CODEX_HOME/skills ou ~/.codex/skills.
 Quando --source aponta para docs/skill-candidates, todas as pastas versionadas v*
@@ -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.');