@fprad0/skill-master-mcp 0.0.7 → 0.0.9

package/bin/skill-master-activation.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import prompts from 'prompts';
+import { buildCatalog, loadConfig } from '../dist/catalog.js';
+import { routeSkillMasterPrompt } from '../dist/prompt-router.js';
+
+const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const skillMasterHome = process.env.SKILL_MASTER_HOME ?? path.join(os.homedir(), '.skill-master');
+const activationConfigPath = process.env.SKILL_MASTER_ACTIVATION_CONFIG
+  ?? path.join(skillMasterHome, 'activation.json');
+const sourcesConfigPath = process.env.SKILL_MASTER_CONFIG ?? path.join(rootDir, 'sources.json');
+const workspace = process.env.SKILL_MASTER_WORKSPACE ?? process.cwd();
+
+const defaultConfig = {
+  activationMode: 'balanced',
+  riskTolerance: 'normal',
+};
+
+const isTty = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+
+const readActivationConfig = () => {
+  if (!existsSync(activationConfigPath)) return defaultConfig;
+  return { ...defaultConfig, ...JSON.parse(readFileSync(activationConfigPath, 'utf8')) };
+};
+
+const writeActivationConfig = (config) => {
+  mkdirSync(path.dirname(activationConfigPath), { recursive: true });
+  writeFileSync(activationConfigPath, JSON.stringify(config, null, 2), 'utf8');
+};
+
+const parseArgs = (argv) => {
+  const parsed = {
+    command: 'status',
+    mode: null,
+    prompt: null,
+    format: 'markdown',
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--status') parsed.command = 'status';
+    else if (arg === '--set-mode') {
+      parsed.command = 'set-mode';
+      parsed.mode = argv[++index] ?? null;
+    } else if (arg === '--route-prompt') {
+      parsed.command = 'route-prompt';
+      parsed.prompt = argv[++index] ?? null;
+    } else if (arg === '--route-prompt-interactive') parsed.command = 'route-prompt-interactive';
+    else if (arg === '--notion-summary') parsed.command = 'notion-summary';
+    else if (arg === '--json') parsed.format = 'json';
+    else if (arg === '--help' || arg === '-h') parsed.command = 'help';
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return parsed;
+};
+
+const loadSkills = async () => {
+  const config = await loadConfig(sourcesConfigPath);
+  const catalog = await buildCatalog(config, { cwd: workspace, includeWeb: false });
+  return catalog.skills;
+};
+
+const routePrompt = async (prompt, { format }) => {
+  if (!prompt) throw new Error('Missing prompt.');
+  const config = readActivationConfig();
+  const skills = await loadSkills();
+  const decision = routeSkillMasterPrompt(skills, prompt, {
+    activationMode: config.activationMode,
+    riskTolerance: config.riskTolerance,
+    limit: 8,
+    sourceKinds: ['workspace', 'local', 'plugin'],
+  });
+
+  if (format === 'json') {
+    console.log(JSON.stringify(decision, null, 2));
+    return;
+  }
+
+  console.log('Skill Master - prompt router');
+  console.log(`- Ativar: ${decision.shouldActivate ? 'sim' : 'nao'}`);
+  console.log(`- Modo: ${decision.activationMode}`);
+  console.log(`- Execucao: ${decision.executionMode}`);
+  console.log(`- Persona: ${decision.personaOverlay}`);
+  console.log(`- Proxima acao: ${decision.nextAction}`);
+  if (decision.recommendedSkills.length > 0) {
+    console.log('- Skills:');
+    for (const skill of decision.recommendedSkills.slice(0, 5)) {
+      console.log(`  - ${skill.name} (${skill.source})`);
+    }
+  }
+};
+
+const printStatus = () => {
+  const config = readActivationConfig();
+  console.log('Skill Master - modo de ativacao');
+  console.log(`- Config: ${activationConfigPath}`);
+  console.log(`- Modo: ${config.activationMode}`);
+  console.log(`- Tolerancia de risco: ${config.riskTolerance}`);
+  console.log(`- Workspace: ${workspace}`);
+};
+
+const setMode = (mode) => {
+  if (!['manual', 'balanced', 'always-on-assisted'].includes(mode)) {
+    throw new Error('Mode must be manual, balanced, or always-on-assisted.');
+  }
+  const config = { ...readActivationConfig(), activationMode: mode };
+  writeActivationConfig(config);
+  console.log(`Modo de ativacao atualizado para: ${mode}`);
+};
+
+const routePromptInteractive = async (format) => {
+  if (!isTty()) throw new Error('Interactive prompt routing requires a TTY.');
+  const response = await prompts({
+    type: 'text',
+    name: 'prompt',
+    message: 'Qual prompt voce quer avaliar?',
+    validate: (value) => value.trim().length >= 3 || 'Informe ao menos 3 caracteres.',
+  });
+  await routePrompt(response.prompt, { format });
+};
+
+const printNotionSummary = () => {
+  const config = readActivationConfig();
+  console.log('## Resumo para Notion - Skill Master Activation');
+  console.log('');
+  console.log(`- Modo atual: ${config.activationMode}`);
+  console.log(`- Tolerancia de risco: ${config.riskTolerance}`);
+  console.log(`- Workspace: ${workspace}`);
+  console.log('- Politica: nenhuma publicacao sem autorizacao explicita.');
+  console.log('- Recomendacao: registrar mudancas de modo, decisoes de skills aprendidas e releases pendentes no ledger do Skill Master.');
+};
+
+const printHelp = () => {
+  console.log(`Skill Master Activation
+
+Usage:
+  skill-master-activation --status
+  skill-master-activation --set-mode manual|balanced|always-on-assisted
+  skill-master-activation --route-prompt "prompt" [--json]
+  skill-master-activation --route-prompt-interactive
+  skill-master-activation --notion-summary
+`);
+};
+
+try {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.command === 'help') printHelp();
+  else if (args.command === 'status') printStatus();
+  else if (args.command === 'set-mode') setMode(args.mode);
+  else if (args.command === 'route-prompt') await routePrompt(args.prompt, { format: args.format });
+  else if (args.command === 'route-prompt-interactive') await routePromptInteractive(args.format);
+  else if (args.command === 'notion-summary') printNotionSummary();
+  else throw new Error(`Unsupported command: ${args.command}`);
+} catch (error) {
+  process.stderr.write(`[skill_master] ${error instanceof Error ? error.message : String(error)}\n`);
+  process.exitCode = 1;
+}

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

@@ -0,0 +1,35 @@
+#!/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 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-eval-activation.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+import { runActivationEvals } from '../dist/activation-evals.js';
+
+const report = runActivationEvals();
+const asJson = process.argv.includes('--json');
+
+if (asJson) {
+  console.log(JSON.stringify(report, null, 2));
+} else {
+  console.log('Skill Master Activation Evals');
+  console.log(`- Generated at: ${report.generatedAt}`);
+  console.log(`- Total: ${report.total}`);
+  console.log(`- Passed: ${report.passed}`);
+  console.log(`- Failed: ${report.failed}`);
+  console.log(`- Accuracy: ${(report.accuracy * 100).toFixed(1)}%`);
+  console.log(`- False positives: ${report.falsePositives}`);
+  console.log(`- False negatives: ${report.falseNegatives}`);
+  console.log(`- Correct blocks: ${report.correctBlocks}`);
+  console.log(`- Recommendation: ${report.recommendation}`);
+
+  const failed = report.results.filter((result) => !result.passed);
+  if (failed.length > 0) {
+    console.log('');
+    console.log('Failed cases:');
+    for (const result of failed) {
+      console.log(`- ${result.case.id}: ${result.findings.join('; ')}`);
+    }
+  }
+}
+
+process.exitCode = report.recommendation === 'balanced-ready' ? 0 : 1;

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

@@ -0,0 +1,77 @@
+#!/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', 'v0.0.9');
+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
+
+Instala as skills globais embutidas em CODEX_HOME/skills ou ~/.codex/skills.
+`);
+  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 skills = readdirSync(source, { withFileTypes: true })
+  .filter((entry) => entry.isDirectory())
+  .map((entry) => entry.name)
+  .sort();
+
+if (!dryRun) {
+  mkdirSync(target, { recursive: true });
+}
+
+const installed = [];
+const skipped = [];
+
+for (const skill of skills) {
+  const from = path.join(source, skill);
+  const to = path.join(target, skill);
+  if (existsSync(to) && !overwrite) {
+    skipped.push(skill);
+    continue;
+  }
+  if (!dryRun) {
+    cpSync(from, to, { recursive: true, force: overwrite });
+  }
+  installed.push(skill);
+}
+
+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-register-clients.mjs

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+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 client registration
+
+Uso:
+  skill-master-register-clients --write-snippets
+  skill-master-register-clients --apply-codex
+  skill-master-register-clients --apply-claude
+  skill-master-register-clients --apply-gemini
+  skill-master-register-clients --apply-all
+  skill-master-register-clients --apply-codex --force
+
+Registra o servidor MCP skill_master como stdio usando o binario global:
+  skill-master-mcp
+`);
+  process.exit(0);
+}
+
+const home = os.homedir();
+const snippetsDir = readValue('--snippets-dir', path.join(home, '.skill-master', 'client-configs'));
+const codexConfig = readValue('--codex-config', path.join(process.env.CODEX_HOME ?? path.join(home, '.codex'), 'config.toml'));
+const claudeConfig = readValue('--claude-config', path.join(home, '.config', 'Claude', 'claude_desktop_config.json'));
+const geminiConfig = readValue('--gemini-config', path.join(home, '.gemini', 'settings.json'));
+
+const applyAll = has('--apply-all');
+const applyCodex = applyAll || has('--apply-codex');
+const applyClaude = applyAll || has('--apply-claude');
+const applyGemini = applyAll || has('--apply-gemini');
+const writeSnippets = applyAll || has('--write-snippets') || !(applyCodex || applyClaude || applyGemini);
+const force = has('--force');
+
+const mcpServer = {
+  command: 'skill-master-mcp',
+  args: [],
+  env: {
+    SKILL_MASTER_UPDATE_CHANNEL: 'stable',
+  },
+};
+
+const codexBlock = `
+[mcp_servers.skill_master]
+command = "skill-master-mcp"
+startup_timeout_sec = 120
+
+[mcp_servers.skill_master.env]
+SKILL_MASTER_UPDATE_CHANNEL = "stable"
+`;
+
+const claudeSnippet = {
+  mcpServers: {
+    skill_master: mcpServer,
+  },
+};
+
+const geminiSnippet = {
+  mcpServers: {
+    skill_master: mcpServer,
+  },
+};
+
+const ensureParent = (filePath) => mkdirSync(path.dirname(filePath), { recursive: true });
+
+const readJsonOrEmpty = (filePath) => {
+  if (!existsSync(filePath)) return {};
+  const raw = readFileSync(filePath, 'utf8').trim();
+  return raw ? JSON.parse(raw) : {};
+};
+
+const writeJson = (filePath, value) => {
+  ensureParent(filePath);
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+};
+
+const mergeMcpServer = (filePath) => {
+  const current = readJsonOrEmpty(filePath);
+  const next = {
+    ...current,
+    mcpServers: {
+      ...(current.mcpServers ?? {}),
+      skill_master: mcpServer,
+    },
+  };
+  writeJson(filePath, next);
+};
+
+const writeSnippetsFiles = () => {
+  mkdirSync(snippetsDir, { recursive: true });
+  writeFileSync(path.join(snippetsDir, 'codex.config.toml'), codexBlock.trimStart(), 'utf8');
+  writeJson(path.join(snippetsDir, 'claude_desktop_config.skill_master.json'), claudeSnippet);
+  writeJson(path.join(snippetsDir, 'gemini.settings.skill_master.json'), geminiSnippet);
+};
+
+const removeCodexBlock = (content) => {
+  const lines = content.split('\n');
+  const kept = [];
+  let skipping = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === '[mcp_servers.skill_master]') {
+      skipping = true;
+      continue;
+    }
+    if (skipping && trimmed.startsWith('[') && !trimmed.startsWith('[mcp_servers.skill_master')) {
+      skipping = false;
+    }
+    if (!skipping) kept.push(line);
+  }
+  return kept.join('\n').trimEnd();
+};
+
+const appendCodex = () => {
+  ensureParent(codexConfig);
+  const current = existsSync(codexConfig) ? readFileSync(codexConfig, 'utf8') : '';
+  if (current.includes('[mcp_servers.skill_master]') && !force) {
+    return false;
+  }
+  const base = force ? removeCodexBlock(current) : current.trimEnd();
+  writeFileSync(codexConfig, `${base}\n${codexBlock}`, 'utf8');
+  return true;
+};
+
+const actions = [];
+if (writeSnippets) {
+  writeSnippetsFiles();
+  actions.push(`snippets written to ${snippetsDir}`);
+}
+if (applyCodex) {
+  actions.push(appendCodex() ? `Codex registered at ${codexConfig}` : `Codex already had skill_master at ${codexConfig}`);
+}
+if (applyClaude) {
+  mergeMcpServer(claudeConfig);
+  actions.push(`Claude config merged at ${claudeConfig}`);
+}
+if (applyGemini) {
+  mergeMcpServer(geminiConfig);
+  actions.push(`Gemini config merged at ${geminiConfig}`);
+}
+
+console.log('[skill_master] Client registration');
+for (const action of actions) {
+  console.log(`- ${action}`);
+}
+console.log('- Restart Codex, Claude or Gemini after registration.');