@fprad0/skill-master-mcp 0.0.6 → 0.0.8

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-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-menu.mjs

@@ -1,179 +1,172 @@
 #!/usr/bin/env node
 
-import { spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import prompts from 'prompts';
+import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { createInterface } from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
-
-const rootDir = dirname(dirname(fileURLToPath(import.meta.url)));
-
-const commands = {
-  status: {
-    label: 'Mostrar status local',
-    command: process.execPath,
-    args: [fileURLToPath(import.meta.url), '--status'],
-  },
-  check: {
-    label: 'Rodar gate completo',
-    command: 'npm',
-    args: ['run', 'check'],
-  },
-  build: {
-    label: 'Rodar build',
-    command: 'npm',
-    args: ['run', 'build'],
-  },
-  publicNpm: {
-    label: 'Validar pacote no npm publico',
-    command: 'npm',
-    args: [
-      'view',
-      '@fprad0/skill-master-mcp',
-      'version',
-      '--registry=https://registry.npmjs.org',
-    ],
-  },
-  updateGlobal: {
-    label: 'Atualizar pacote global via npm',
-    command: process.execPath,
-    args: [join(rootDir, 'bin', 'skill-master-update.mjs')],
-  },
-  privateRegistry: {
-    label: 'Configurar registry privado GitHub Packages',
-    command: process.execPath,
-    args: ['scripts/configure-private-registry.mjs', '--validate'],
-  },
-};
-
-const menuItems = [
-  ['1', commands.status],
-  ['2', commands.check],
-  ['3', commands.build],
-  ['4', commands.publicNpm],
-  ['5', commands.updateGlobal],
-  ['6', commands.privateRegistry],
-];
-
-function readJson(relativePath) {
-  const target = join(rootDir, relativePath);
-  if (!existsSync(target)) {
-    return null;
+import {
+  buildMenuChoices,
+  buildMenuCommands,
+  formatActionHeader,
+  formatHelp,
+  formatMenuBanner,
+  formatResultMessage,
+  formatStatusReport,
+  getMenuStatus,
+  isInteractiveTerminal,
+  resolveActionKey,
+  runCommand,
+} from './lib/menu-core.mjs';
+
+const currentFile = fileURLToPath(import.meta.url);
+const rootDir = dirname(dirname(currentFile));
+const commands = buildMenuCommands({ rootDir, currentFile });
+
+function parseArgs(argv) {
+  const parsed = {
+    help: false,
+    status: false,
+    yes: false,
+    run: null,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    switch (arg) {
+      case '--help':
+      case '-h':
+        parsed.help = true;
+        break;
+      case '--status':
+        parsed.status = true;
+        break;
+      case '--yes':
+        parsed.yes = true;
+        break;
+      case '--run':
+        parsed.run = argv[++i] ?? null;
+        break;
+      default:
+        throw new Error(`Unknown argument: ${arg}`);
+    }
   }
 
-  return JSON.parse(readFileSync(target, 'utf8'));
+  return parsed;
 }
 
-function readText(relativePath) {
-  const target = join(rootDir, relativePath);
-  if (!existsSync(target)) {
-    return null;
-  }
+function printHelp() {
+  console.log(formatHelp(commands));
+}
 
-  return readFileSync(target, 'utf8').trim();
+function printStatus() {
+  console.log(formatStatusReport(getMenuStatus(rootDir)));
 }
 
-function printHelp() {
-  console.log(`Skill Master Menu
+async function runSelectedAction(action, { yes = false, useColor = false } = {}) {
+  if (action.confirmMessage && !yes) {
+    if (!isInteractiveTerminal()) {
+      throw new Error(`Action ${action.key} requires --yes outside an interactive terminal.`);
+    }
 
-Uso:
-  skill-master-menu
-  skill-master-menu --status
-  skill-master-menu --help
+    const confirmation = await prompts({
+      type: 'confirm',
+      name: 'confirmed',
+      message: action.confirmMessage,
+      initial: false,
+    });
 
-Opcao 5 do menu:
-  atualiza o pacote global com npm install -g @fprad0/skill-master-mcp@latest
+    if (!confirmation.confirmed) {
+      return { cancelled: true, code: 0 };
+    }
+  }
 
-O comando de menu e voltado para operacao humana. O binario MCP stdio continua sendo:
-  skill-master-mcp
-`);
+  console.log('');
+  console.log(formatActionHeader(action, { useColor }));
+  console.log('');
+  const code = await runCommand(action, { cwd: rootDir });
+  console.log('');
+  console.log(formatResultMessage(code, { useColor }));
+  return { cancelled: false, code };
 }
 
-function printStatus() {
-  const packageJson = readJson('package.json');
-  const stableManifest = readJson('manifests/channels/stable.json');
-  const versionText = readText('VERSION.md');
-
-  console.log('Skill Master MCP - status local');
-  console.log(`Diretorio: ${rootDir}`);
-  console.log(`Pacote: ${packageJson?.name ?? 'nao encontrado'}`);
-  console.log(`Semver local: ${packageJson?.version ?? 'nao encontrado'}`);
-  console.log(`Manifesto stable: ${stableManifest?.version ?? 'nao encontrado'}`);
-  console.log(`Manifesto semver: ${stableManifest?.semver ?? 'nao encontrado'}`);
-
-  if (versionText) {
-    const firstLines = versionText.split('\n').slice(0, 6).join('\n');
-    console.log('\nVERSION.md:');
-    console.log(firstLines);
-  }
-}
+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,
+    });
 
-function runCommand(commandConfig) {
-  return new Promise((resolve) => {
-    console.log(`\n> ${commandConfig.command} ${commandConfig.args.join(' ')}\n`);
+    if (!selection.action || selection.action === '__exit__') {
+      return 0;
+    }
 
-    const child = spawn(commandConfig.command, commandConfig.args, {
-      cwd: rootDir,
-      env: process.env,
-      shell: process.platform === 'win32',
-      stdio: 'inherit',
-    });
+    const action = commands.find((entry) => entry.key === selection.action);
+    if (!action) {
+      return 1;
+    }
 
-    child.on('close', (code) => {
-      resolve(code ?? 1);
+    const result = await runSelectedAction(action, { useColor: true });
+    if (result.cancelled) {
+      continue;
+    }
+
+    const nextStep = await prompts({
+      type: 'toggle',
+      name: 'keepGoing',
+      message: 'Voltar ao menu?',
+      initial: true,
+      active: 'sim',
+      inactive: 'nao',
     });
-  });
-}
 
-async function runInteractiveMenu() {
-  const rl = createInterface({ input, output });
-
-  try {
-    while (true) {
-      console.log('\nSkill Master Menu');
-      for (const [key, item] of menuItems) {
-        console.log(`  ${key}. ${item.label}`);
-      }
-      console.log('  0. Sair');
-
-      const answer = (await rl.question('\nEscolha uma opcao: ')).trim();
-
-      if (answer === '0' || answer.toLowerCase() === 'q') {
-        return 0;
-      }
-
-      const selected = menuItems.find(([key]) => key === answer)?.[1];
-      if (!selected) {
-        console.log('Opcao invalida.');
-        continue;
-      }
-
-      const code = await runCommand(selected);
-      if (code !== 0) {
-        console.log(`\nComando terminou com codigo ${code}.`);
-      }
+    if (!nextStep.keepGoing) {
+      return result.code;
     }
-  } finally {
-    rl.close();
   }
 }
 
 async function main() {
-  const args = process.argv.slice(2);
+  const args = parseArgs(process.argv.slice(2));
 
-  if (args.includes('--help') || args.includes('-h')) {
+  if (args.help) {
     printHelp();
     return 0;
   }
 
-  if (args.includes('--status')) {
+  if (args.status) {
     printStatus();
     return 0;
   }
 
-  return runInteractiveMenu();
+  if (args.run) {
+    const actionKey = resolveActionKey(args.run, commands);
+    if (!actionKey) {
+      throw new Error(`Unknown action: ${args.run}`);
+    }
+
+    const action = commands.find((entry) => entry.key === actionKey);
+    const result = await runSelectedAction(action, { yes: args.yes, useColor: isInteractiveTerminal() });
+    return result.code;
+  }
+
+  if (!isInteractiveTerminal()) {
+    throw new Error('Interactive menu requires a TTY. Use --run <acao> or --status in automated environments.');
+  }
+
+  return runVisualMenu();
 }
 
-const exitCode = await main();
-process.exitCode = exitCode;
+try {
+  process.exitCode = await main();
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`[skill_master] ${message}\n`);
+  process.exitCode = 1;
+}