shakers-cli-beta 0.8.0-beta.0

package/src/lang-flow.js

@@ -0,0 +1,85 @@
+'use strict';
+
+// `lang` flow: view the talent's languages + levels, and `--set` (interactive,
+// confirmation) to add/update one. The write is REPLACE-ALL, so we merge the
+// chosen language into the current set and PATCH the whole list.
+
+const { styleLabelPrefix } = require('./ansi');
+const { LEVELS } = require('./lang-client');
+
+function makeLangDeps(overrides = {}) {
+  const client = require('./lang-client');
+  return {
+    fetchLanguages: (opts) => client.fetchLanguages({}, opts),
+    fetchLanguageCatalog: (opts) => client.fetchLanguageCatalog({}, opts),
+    saveLanguages: (opts) => client.saveLanguages({}, opts),
+    promptSelect: (opts) => require('./prompt-select').promptSelect(opts),
+    ...overrides,
+  };
+}
+
+function renderView(io, fp, languages) {
+  io.section(fp.title);
+  if (!languages.length) { io.notify(fp.none); io.success(fp.done); return; }
+  languages.forEach((l) => io.notify(styleLabelPrefix(fp.line(l.name || l.code || fp.unknownLang, l.level ? fp.levelLabel(l.level) : fp.unknownLevel))));
+  io.success(fp.done);
+}
+
+async function runSet({ io, ask, session, catalog, opts, deps }) {
+  const fp = catalog.lang;
+  const hubAccessToken = session ? session.hubAccessToken : null;
+  if (!opts.stdinIsTTY) { io.error(fp.setNeedsInteractive); return { ok: false, reason: 'non-interactive' }; }
+  const selOut = (s) => io.notify(s);
+
+  const cur = await io.withProgress(fp.loading, () => deps.fetchLanguages({ hubAccessToken }));
+  if (!cur.ok) { io.error(fp.fetchFailed(cur.reason)); return { ok: false, reason: cur.reason }; }
+  const cat = await io.withProgress(fp.loadingCatalog, () => deps.fetchLanguageCatalog({}));
+  if (!cat.ok) { io.error(fp.catalogFailed(cat.reason)); return { ok: false, reason: cat.reason }; }
+
+  const current = Array.isArray(cur.languages) ? cur.languages : [];
+  io.section(fp.setTitle);
+  if (current.length) current.forEach((l) => io.notify(styleLabelPrefix(fp.line(l.name || l.code, l.level ? fp.levelLabel(l.level) : fp.unknownLevel))));
+
+  const langItem = await deps.promptSelect({
+    ask, stdinIsTTY: opts.stdinIsTTY, out: selOut, header: fp.pickLanguage,
+    items: cat.catalog, labelFor: (l) => l.name, input: opts.input, output: opts.output,
+  });
+  if (!langItem) { io.notify(fp.setCancelled); return { ok: true, cancelled: true }; }
+
+  const levelItem = await deps.promptSelect({
+    ask, stdinIsTTY: opts.stdinIsTTY, out: selOut, header: fp.pickLevel,
+    items: LEVELS.map((v) => ({ label: fp.levelLabel(v), value: v })), labelFor: (x) => x.label, input: opts.input, output: opts.output,
+  });
+  if (!levelItem) { io.notify(fp.setCancelled); return { ok: true, cancelled: true }; }
+
+  // Merge into the full set (replace-all): keep every other language, upsert this one.
+  const merged = current.filter((l) => l.id !== langItem.id).map((l) => ({ id: l.id, level: l.level }));
+  merged.push({ id: langItem.id, level: levelItem.value });
+
+  io.notify(fp.setDiff(langItem.name, fp.levelLabel(levelItem.value)));
+  const confirmed = await io.confirm(fp.setConfirm);
+  if (!confirmed) { io.notify(fp.setCancelled); return { ok: true, cancelled: true }; }
+
+  const res = await io.withProgress(fp.setSaving, () => deps.saveLanguages({ hubAccessToken, languages: merged }));
+  if (!res.ok) { io.error(fp.setFailed(res.reason)); return { ok: false, reason: res.reason }; }
+  io.success(fp.setDone(langItem.name));
+  return { ok: true, set: { id: langItem.id, level: levelItem.value } };
+}
+
+async function runLang({ io, rawOut, ask, session, catalog, opts = {}, deps = makeLangDeps() }) {
+  const fp = catalog.lang;
+  if (opts.set) return runSet({ io, ask, session, catalog, opts, deps });
+
+  const hubAccessToken = session ? session.hubAccessToken : null;
+  const doFetch = () => deps.fetchLanguages({ hubAccessToken });
+  const res = opts.json ? await doFetch() : await io.withProgress(fp.loading, doFetch);
+  if (!res.ok) { io.error(fp.fetchFailed(res.reason)); return { ok: false, reason: res.reason }; }
+  if (opts.json) {
+    (rawOut || ((s) => process.stdout.write(s)))(`${JSON.stringify({ ok: true, languages: res.languages }, null, 2)}\n`);
+    return { ok: true, languages: res.languages };
+  }
+  renderView(io, fp, res.languages);
+  return { ok: true, languages: res.languages };
+}
+
+module.exports = { makeLangDeps, runLang, renderView };

package/src/legal-notice.js

@@ -0,0 +1,53 @@
+'use strict';
+
+// Shared PRESENTATION for the CLI's legal/consent disclosures (talents-ai-score).
+
+const { palette, colorEnabled } = require('./ansi');
+const { BRAND_ANSI } = require('./brand-ansi');
+
+const RULE_CHAR = '─';
+const RULE_WIDTH = 62;
+
+function renderLegalNotice(text, catalog, { stream = process.stdout } = {}) {
+  if (!colorEnabled({ stream })) return text;
+  const ANSI = palette({ reset: '\x1b[0m', bold: '\x1b[1m', warning: BRAND_ANSI.warning }, { stream });
+  const rule = `${ANSI.warning}${RULE_CHAR.repeat(RULE_WIDTH)}${ANSI.reset}`;
+  const label = catalog && catalog.legalNotice ? catalog.legalNotice.label : null;
+  const lines = [];
+  if (label) lines.push(`${ANSI.bold}${ANSI.warning}⚠ ${label}${ANSI.reset}`);
+  lines.push(rule, text, rule);
+  // TRAILING NEWLINE (colour path only) — WHERE THE ANSWER LANDS.
+  return lines.join('\n') + '\n';
+}
+
+function splitTrailingPrompt(text) {
+  const s = String(text == null ? '' : text);
+  const bracket = s.match(/\[[^\]\n]*\/[^\]\n]*\]\s*$/);
+  if (!bracket) return { body: s, prompt: '' };
+  const beforeBracket = s.slice(0, bracket.index).replace(/\s+$/, '');
+  if (!beforeBracket) return { body: '', prompt: s }; // the bracket IS the whole text
+  const lastChar = beforeBracket.slice(-1);
+  const isSentenceEnd = lastChar === '.' || lastChar === '?' || lastChar === '!';
+  // Search for the PRECEDING boundary in everything BEFORE that terminator — never in the terminator itself.
+  const searchIn = isSentenceEnd ? beforeBracket.slice(0, -1) : beforeBracket;
+  const boundary = Math.max(searchIn.lastIndexOf('. '), searchIn.lastIndexOf('? '), searchIn.lastIndexOf('! '));
+  if (boundary === -1) return { body: '', prompt: s };
+  return { body: s.slice(0, boundary + 1), prompt: s.slice(boundary + 2) };
+}
+
+// Returns `{ box, prompt }`.
+function renderLegalNoticeSplit(text, catalog, { stream = process.stdout } = {}) {
+  if (!colorEnabled({ stream })) return { box: null, prompt: text };
+  const { body, prompt } = splitTrailingPrompt(text);
+  if (!prompt) return { box: renderLegalNotice(text, catalog, { stream }), prompt: null };
+  const ANSI = palette({ reset: '\x1b[0m', bold: '\x1b[1m', warning: BRAND_ANSI.warning }, { stream });
+  const rule = `${ANSI.warning}${RULE_CHAR.repeat(RULE_WIDTH)}${ANSI.reset}`;
+  const label = catalog && catalog.legalNotice ? catalog.legalNotice.label : null;
+  const lines = [];
+  if (label) lines.push(`${ANSI.bold}${ANSI.warning}⚠ ${label}${ANSI.reset}`);
+  if (body) lines.push(rule, body, rule);
+  else lines.push(rule); // the whole text WAS the question — nothing to box.
+  return { box: lines.join('\n'), prompt };
+}
+
+module.exports = { renderLegalNotice, renderLegalNoticeSplit, splitTrailingPrompt };

package/src/locale.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const { execFileSync } = require('child_process');
+
+// Operating system language detection, to localize the report (see i18n.js).
+
+// Extracts a 2-letter language code ("es", "en"...) from a common locale string: "es_ES.UTF-8", "es-ES", "es", or a list "es_ES:en" (LANGUAGE format, the first element is taken).
+function langFromLocaleString(raw) {
+  if (!raw) return null;
+  const value = String(raw).trim();
+  if (!value || /^(c|posix)$/i.test(value)) return null;
+  const first = value.split(':')[0];
+  const match = first.match(/^([a-zA-Z]{2})/);
+  return match ? match[1].toLowerCase() : null;
+}
+
+function langFromEnv(env) {
+  for (const key of ['LC_ALL', 'LANG', 'LANGUAGE']) {
+    const lang = langFromLocaleString(env[key]);
+    if (lang) return lang;
+  }
+  return null;
+}
+
+function langFromAppleLocale() {
+  if (process.platform !== 'darwin') return null;
+  try {
+    const out = execFileSync('defaults', ['read', '-g', 'AppleLocale'], {
+      timeout: 2000,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).toString('utf8');
+    return langFromLocaleString(out);
+  } catch {
+    return null; // key not set, command missing, or any other failure: ignored
+  }
+}
+
+function langFromIntl() {
+  try {
+    return langFromLocaleString(Intl.DateTimeFormat().resolvedOptions().locale);
+  } catch {
+    return null;
+  }
+}
+
+// Returns the detected language code ('es', 'en', 'fr', ...) or null if no signal could be resolved.
+function detectLangCode(env = process.env) {
+  return langFromEnv(env) || langFromAppleLocale() || langFromIntl() || null;
+}
+
+module.exports = { detectLangCode, langFromLocaleString };

package/src/markdown-ansi.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const { palette } = require('./ansi');
+const { BRAND_ANSI } = require('./brand-ansi');
+
+function mdPalette(opts = {}) {
+  return palette({
+    bold: '\x1b[1m',
+    italic: '\x1b[3m',
+    dim: '\x1b[2m',
+    code: BRAND_ANSI.accent,
+    heading: `\x1b[1m${BRAND_ANSI.primary}`,
+    reset: '\x1b[0m',
+  }, opts);
+}
+
+function inline(text, C) {
+  const codes = [];
+  let s = String(text).replace(/`([^`]+)`/g, (_m, c) => { codes.push(c); return `\u0000${codes.length - 1}\u0000`; });
+  s = s.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, t, u) => `${t} (${u})`);
+  s = s.replace(/\*\*([^*]+)\*\*/g, (_m, x) => `${C.bold}${x}${C.reset}`);
+  s = s.replace(/__([^_]+)__/g, (_m, x) => `${C.bold}${x}${C.reset}`);
+  s = s.replace(/(^|[^*])\*([^*\n]+)\*(?!\*)/g, (_m, p, x) => `${p}${C.italic}${x}${C.reset}`);
+  s = s.replace(/(^|[^_\w])_([^_\n]+)_(?![_\w])/g, (_m, p, x) => `${p}${C.italic}${x}${C.reset}`);
+  s = s.replace(/\u0000(\d+)\u0000/g, (_m, i) => `${C.code}${codes[Number(i)]}${C.reset}`);
+  return s;
+}
+
+function renderMarkdown(text, opts = {}) {
+  const C = mdPalette(opts);
+  const lines = String(text ?? '').split('\n');
+  const out = [];
+  let inFence = false;
+  for (const raw of lines) {
+    if (/^\s*```/.test(raw)) { inFence = !inFence; continue; }
+    if (inFence) { out.push(`${C.dim}${raw}${C.reset}`); continue; }
+    const h = raw.match(/^\s*(#{1,6})\s+(.*)$/);
+    if (h) { out.push(`${C.heading}${inline(h[2], C)}${C.reset}`); continue; }
+    const bq = raw.match(/^\s*>\s?(.*)$/);
+    if (bq) { out.push(`${C.dim}│${C.reset} ${inline(bq[1], C)}`); continue; }
+    const b = raw.match(/^(\s*)[-*+]\s+(.*)$/);
+    if (b) { out.push(`${b[1]}${C.bold}•${C.reset} ${inline(b[2], C)}`); continue; }
+    const n = raw.match(/^(\s*)(\d+)\.\s+(.*)$/);
+    if (n) { out.push(`${n[1]}${C.bold}${n[2]}.${C.reset} ${inline(n[3], C)}`); continue; }
+    out.push(inline(raw, C));
+  }
+  return out.join('\n');
+}
+
+module.exports = { renderMarkdown };

package/src/maturity.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const { computeTierResult, AGENTIC_IDS } = require('./tier-engine');
+
+// AI usage maturity classification.
+
+const LEVELS = [
+  { level: 0, key: 'none', name: 'Sin rastro de IA', emoji: '○' },
+  { level: 1, key: 'exploring', name: 'Explorando', emoji: '◔' },
+  { level: 2, key: 'integrated', name: 'Integrado', emoji: '◑' },
+  { level: 3, key: 'power', name: 'Power user', emoji: '◕' },
+  { level: 4, key: 'orchestrator', name: 'Orquestador', emoji: '●' },
+];
+
+// DECISION (talents-ai-score, signal expansion): the level definitions (LEVELS, HANDOFF §4) have NOT been touched.
+function depthTotals(tools) {
+  let instructions = 0; // project instructions/rules files
+  let mcp = 0; // configured MCP servers
+  let custom = 0; // own skills + commands + rules
+  let hooks = 0;
+
+  for (const t of tools) {
+    if (!t.detected) continue;
+    const d = t.depth || {};
+    instructions += (d.instructions || 0) + (d.config || 0);
+    mcp += d.mcpServers || 0;
+    custom += (d.skills || 0) + (d.commands || 0) + (d.rules || 0);
+    hooks += d.hooks || 0;
+  }
+  return { instructions, mcp, custom, hooks };
+}
+
+// Score model 0-100 for the visual meter — RECALIBRATED (ADR-008, skill-code-certification).
+const SCORE_MODEL = [
+  { key: 'breadth', weight: 12, full: 3 }, // number of AI tools detected
+  { key: 'context', weight: 16, full: 2 }, // instructions + config files
+  { key: 'mcp', weight: 18, full: 2 }, // configured MCP servers
+  { key: 'custom', weight: 20, full: 4 }, // own skills + commands + rules
+  { key: 'agentic', weight: 8, full: 1 }, // has an agentic CLI (0/1)
+  { key: 'hooks', weight: 14, full: 1 }, // hook-based automation
+  { key: 'multiAgent', weight: 12, full: 2 }, // agent definitions (>=2 = top)
+];
+
+function computeScore({ breadth, context, mcp, custom, agentic, hooks, multiAgent }) {
+  const values = { breadth, context, mcp, custom, agentic, hooks, multiAgent };
+  let total = 0;
+  for (const dim of SCORE_MODEL) {
+    const v = values[dim.key] || 0;
+    total += dim.weight * Math.min(v / dim.full, 1);
+  }
+  return Math.max(0, Math.min(100, Math.round(total)));
+}
+
+function classify(report) {
+  const detected = report.tools.filter((t) => t.detected);
+  const breadth = detected.length;
+  const d = depthTotals(detected);
+  const hasAgentic = detected.some((t) => AGENTIC_IDS.includes(t.id));
+  const agentCount =
+    report && report.agentCounts && typeof report.agentCounts.agents === 'number'
+      ? report.agentCounts.agents
+      : 0;
+
+  // Score scope reverted to PROJECT ∪ HOME (skill-code-certification / ADR-010, which reverts ADR-009).
+  const score = computeScore({
+    breadth,
+    context: d.instructions, // depthTotals already folds `config` into instructions
+    mcp: d.mcp,
+    custom: d.custom,
+    agentic: hasAgentic ? 1 : 0,
+    hooks: d.hooks,
+    multiAgent: agentCount,
+  });
+
+  // Band 0-4 derived from the tier engine (issue 019, single source of truth).
+  const tierResult = computeTierResult(report);
+  const level = tierResult.band;
+  const meta = LEVELS[level];
+
+  return {
+    level: meta.level,
+    key: meta.key,
+    name: meta.name,
+    emoji: meta.emoji,
+    score,
+    breadth,
+    depth: d,
+    hasAgentic,
+    next: nextStep(level, { breadth, ...d, hasAgentic }),
+    // Tier (T0-T7, issue 019): the fine-grained axis the band is derived from.
+    tier: tierResult.tier,
+    tierKey: tierResult.tierKey,
+    tierName: tierResult.tierName,
+    // Setup Level (ADR-016): the 3-value rollup shown to the talent, derived
+    // from the tier. `{key, code, rank, emoji}`; label localized via i18n.
+    setupLevel: tierResult.setupLevel,
+  };
+}
+
+function nextStep(level) {
+  const steps = {
+    0: 'Instala una herramienta de IA (Claude Code, Cursor o Copilot) y pruébala en un proyecto real.',
+    1: 'Añade un fichero de instrucciones al proyecto (CLAUDE.md, .cursorrules o copilot-instructions.md) para dar contexto persistente.',
+    2: 'Conecta un servidor MCP o crea reglas/comandos propios para que la IA acceda a tus datos y flujos.',
+    3: 'Combina una CLI agéntica con MCP y skills/comandos propios; automatiza una tarea recurrente de principio a fin.',
+    4: 'Ya operas a nivel de orquestación: documenta tu setup y encadena agentes o ejecución en background.',
+  };
+  return steps[level];
+}
+
+module.exports = { classify, LEVELS, AGENTIC_IDS };

package/src/mcp-ai-usage-result-tool.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const FLOOR_METHOD = 'floor';
+const FLOOR_CODE = 'other-1';
+const POLL_INTERVAL_MS = 5000;
+const POLL_CAP_MS = 90000;
+const INVENTORY_TIMEOUT_MS = 15000;
+
+const RESULT_INPUT_SCHEMA = { type: 'object', properties: {} };
+
+function isClassified(agents) {
+  if (agents.length === 0) return false;
+  const anyMethod = agents.some((a) => typeof a.method === 'string' && a.method);
+  if (anyMethod) {
+    return agents.every(
+      (a) => typeof a.method === 'string' && a.method && a.method !== FLOOR_METHOD,
+    );
+  }
+  return agents.every((a) => a.code && a.code !== FLOOR_CODE);
+}
+
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function pollClassifiedInventory({
+  accessToken,
+  endpoint,
+  requestDiscoveredInventory,
+  sleep = defaultSleep,
+  now = () => Date.now(),
+  intervalMs = POLL_INTERVAL_MS,
+  capMs = POLL_CAP_MS,
+}) {
+  const start = now();
+  let agents = [];
+  while (true) {
+    const inv = await requestDiscoveredInventory(
+      { accessToken },
+      { endpoint, timeoutMs: INVENTORY_TIMEOUT_MS },
+    );
+    if (inv.ok) {
+      agents = Array.isArray(inv.agents) ? inv.agents : [];
+      if (isClassified(agents)) {
+        return { status: 'ready', reason: 'classified', agents };
+      }
+    }
+    if (now() - start + intervalMs > capMs) {
+      return { status: 'pending', reason: 'classifying', agents };
+    }
+    await sleep(intervalMs);
+  }
+}
+
+const READY_MESSAGE = 'Shakers finished classifying the agents.';
+const PENDING_MESSAGE = 'Shakers is still classifying the agents — this is normal, call ai_usage_result again shortly to keep waiting.';
+
+function makeAiUsageResultTool(deps = {}) {
+  const {
+    loadAuthSession = require('./auth-session-store').loadAuthSession,
+    sessionStatus = require('./auth-session-store').sessionStatus,
+    getUsageDiscoveredInventoryEndpoint = require('./config').getUsageDiscoveredInventoryEndpoint,
+    requestDiscoveredInventory = require('./inventory-client').requestDiscoveredInventory,
+    sleep = defaultSleep,
+    now = () => Date.now(),
+    intervalMs = POLL_INTERVAL_MS,
+    capMs = POLL_CAP_MS,
+  } = deps;
+
+  async function handler() {
+    const session = loadAuthSession();
+    if (sessionStatus(session) !== 'active') {
+      throw new Error('no active Shakers session — call the login tool (or run `shakers login`) first.');
+    }
+    const endpoint = getUsageDiscoveredInventoryEndpoint();
+    if (!endpoint) {
+      throw new Error('discovered-inventory endpoint is not configured (set SHAKERS_CLI_INGEST_ENDPOINT).');
+    }
+
+    const result = await pollClassifiedInventory({
+      accessToken: session.accessToken,
+      endpoint,
+      requestDiscoveredInventory,
+      sleep,
+      now,
+      intervalMs,
+      capMs,
+    });
+    return {
+      ...result,
+      message: result.status === 'ready' ? READY_MESSAGE : PENDING_MESSAGE,
+    };
+  }
+
+  return {
+    name: 'ai_usage_result',
+    description:
+      "Retrieve the enriched Shakers classification for the talent's agents after ai_usage. Shakers classifies agents and writes their descriptions server-side (no client LLM), so this reads the result: per agent { name, tools, model, category, role, level, code, whatItDoes }. Session-keyed, no arguments. Server-side classification can take a few minutes, so this does a bounded internal poll (~90s max, never a long-held call): returns { status: 'ready', agents } once every agent has been classified, or { status: 'pending', agents } while Shakers is still processing (call it again to keep waiting — 'pending' is normal progress, not an error). Present agents to the talent by NAME and category/role only; the `code` field is an internal handle for add_agent, never show it. Requires an active session.",
+    inputSchema: RESULT_INPUT_SCHEMA,
+    handler,
+  };
+}
+
+module.exports = {
+  makeAiUsageResultTool,
+  isClassified,
+  pollClassifiedInventory,
+  RESULT_INPUT_SCHEMA,
+};