shakers-cli-beta 0.8.0-beta.0

package/src/start-add-skills.js

@@ -0,0 +1,260 @@
+'use strict';
+
+const { getUsageDiscoveredInventoryEndpoint, getSkillsDeclareEndpoint, getPortfoliosListEndpoint, getPortfolioUpdateEndpoint } = require('./config');
+const { requestDeclareSkill } = require('./skills-client');
+const { requestDiscoveredInventory } = require('./inventory-client');
+const { requestListPortfolios, requestUpdatePortfolioSkills } = require('./portfolio-client');
+const { confirmDisclaimerAcceptance } = require('./certify-disclaimer');
+const { runInteractiveMultiSelect } = require('./interactive-select');
+const { loadAuthSession, sessionStatus } = require('./auth-session-store');
+const { styleSuccess } = require('./ansi');
+
+// `start`'s "Añadir skills" route (talents-ai-score, ADR-054/055).
+
+// Maps a technical failure reason to the localized `start.errorReason` copy.
+function reasonCopy(reason, c) {
+  if (typeof reason === 'string' && reason.startsWith('http-')) {
+    return c.errorReasonHttp(reason.slice('http-'.length));
+  }
+  return c.errorReason[reason] || c.errorReason.generic;
+}
+
+function parseMultiIndices(raw, count) {
+  const trimmed = String(raw == null ? '' : raw).trim();
+  if (!trimmed) return null;
+  const parts = trimmed.split(/[\s,]+/).filter(Boolean);
+  const idx = new Set();
+  for (const part of parts) {
+    if (!/^\d+$/.test(part)) return null;
+    const n = Number(part);
+    if (n < 1 || n > count) return null;
+    idx.add(n - 1);
+  }
+  return idx.size > 0 ? [...idx].sort((a, b) => a - b) : null;
+}
+
+// Numbered fallback prompt for the multi-select, mirroring
+// bin/certify.js#askNumberedChoice's shape but for a LIST of indices.
+async function askMultiIndices(ask, promptText, count) {
+  const raw = await ask(promptText);
+  return parseMultiIndices(raw, count);
+}
+
+async function pickSkills({ ask, stdinIsTTY, candidates, c, input, output }) {
+  if (stdinIsTTY && typeof ask.suspend === 'function') {
+    ask.suspend();
+    const picked = await runInteractiveMultiSelect({
+      items: candidates,
+      labelFor: (s) => `${s.skillName}${s.technology ? ` (${s.technology})` : ''}`,
+      header: c.addSkillsSelectHeading,
+      hint: c.addSkillsSelectHint,
+      ...(input ? { input } : {}),
+      ...(output ? { output } : {}),
+    });
+    ask.resume();
+    return picked || [];
+  }
+  process.stdout.write(`\n  ${c.addSkillsSelectHeading}\n`);
+  candidates.forEach((s, i) => {
+    process.stdout.write(`    ${i + 1}) ${s.skillName}${s.technology ? ` (${s.technology})` : ''}\n`);
+  });
+  const idxs = await askMultiIndices(ask, `  ${c.addSkillsSelectPrompt(candidates.length)}`, candidates.length);
+  return idxs ? idxs.map((i) => candidates[i]) : [];
+}
+
+// Declares every chosen skill against the CURRENT `hubAccessToken`.
+async function declareAll(chosen, { accessToken, hubAccessToken }, endpoint, c) {
+  const pending = [];
+  const declared = [];
+  let hubSessionExpired = false;
+  let succeeded = 0;
+  for (const skill of chosen) {
+    if (hubSessionExpired) {
+      pending.push(skill);
+      continue;
+    }
+    const r = await requestDeclareSkill({ skillId: skill.skillId, accessToken, hubAccessToken }, { endpoint });
+    if (r.ok) {
+      process.stdout.write(`  ${styleSuccess(c.addSkillsDeclaredOne(skill.skillName))}\n`);
+      succeeded += 1;
+      declared.push(skill);
+    } else if (r.reason === 'hub-session-expired') {
+      hubSessionExpired = true;
+      pending.push(skill);
+    } else {
+      process.stdout.write(`  ${c.addSkillsDeclareFailed(skill.skillName, reasonCopy(r.reason, c))}\n`);
+    }
+  }
+  return { pending, hubSessionExpired, succeeded, declared };
+}
+
+async function pickPortfolios({ ask, stdinIsTTY, portfolios, heading, c, input, output }) {
+  if (stdinIsTTY && typeof ask.suspend === 'function') {
+    ask.suspend();
+    const picked = await runInteractiveMultiSelect({
+      items: portfolios,
+      labelFor: (p) => p.name,
+      header: heading,
+      hint: c.addSkillsRelateSelectHint,
+      ...(input ? { input } : {}),
+      ...(output ? { output } : {}),
+    });
+    ask.resume();
+    return picked || [];
+  }
+  process.stdout.write(`\n  ${heading}\n`);
+  portfolios.forEach((p, i) => {
+    process.stdout.write(`    ${i + 1}) ${p.name}\n`);
+  });
+  const idxs = await askMultiIndices(ask, `  ${c.addSkillsRelateSelectPrompt(portfolios.length)}`, portfolios.length);
+  return idxs ? idxs.map((i) => portfolios[i]) : [];
+}
+
+async function relateSkillToPortfolios({ ask, stdinIsTTY, skill, portfolios, hubAccessToken, updateEndpoint, c, input, output }) {
+  const wantsRelate = /^(y|yes|s|si|sí)$/i.test(String(await ask(`\n  ${c.addSkillsRelateAsk(skill.skillName)} `)).trim());
+  if (!wantsRelate) {
+    process.stdout.write(`  ${c.addSkillsRelateSkipped(skill.skillName)}\n`);
+    return;
+  }
+  const relateHeading = c.addSkillsRelateSelectHeading(skill.skillName);
+  const chosenPortfolios = await pickPortfolios({ ask, stdinIsTTY, portfolios, heading: relateHeading, c, input, output });
+  if (!chosenPortfolios || chosenPortfolios.length === 0) {
+    process.stdout.write(`  ${c.addSkillsRelateSkipped(skill.skillName)}\n`);
+    return;
+  }
+  for (const portfolio of chosenPortfolios) {
+    const skillIds = Array.from(new Set([...(portfolio.skillIds || []), skill.skillId]));
+    const r = await requestUpdatePortfolioSkills({ portfolioId: portfolio.id, skillIds, hubAccessToken }, { endpoint: updateEndpoint });
+    if (r.ok) {
+      portfolio.skillIds = skillIds;
+      process.stdout.write(`${styleSuccess(c.addSkillsRelated(skill.skillName, portfolio.name))}\n`);
+    } else {
+      process.stdout.write(`${c.addSkillsRelateFailed(skill.skillName, portfolio.name, reasonCopy(r.reason, c))}\n`);
+    }
+  }
+}
+
+async function offerRelateToPortfolios({ ask, stdinIsTTY, declared, session, c, input, output }) {
+  if (!declared || declared.length === 0) return;
+  const listEndpoint = getPortfoliosListEndpoint();
+  const updateEndpoint = getPortfolioUpdateEndpoint();
+  if (!listEndpoint || !updateEndpoint) return;
+
+  const listed = await requestListPortfolios(
+    { accessToken: session.accessToken, hubAccessToken: session.hubAccessToken },
+    { endpoint: listEndpoint },
+  );
+  if (!listed.ok || listed.portfolios.length === 0) {
+    process.stdout.write(`\n  ${c.addSkillsRelateNoPortfolios}\n`);
+    return;
+  }
+
+  for (const skill of declared) {
+    await relateSkillToPortfolios({
+      ask, stdinIsTTY, skill, portfolios: listed.portfolios, hubAccessToken: session.hubAccessToken, updateEndpoint, c, input, output,
+    });
+  }
+}
+
+// The whole route.
+async function runAddSkills({
+  ask, catalog, root, session, stdinIsTTY, input, output, preAccepted = false, deps = {},
+} = {}) {
+  const c = catalog.start;
+  const runLogin = deps.runLogin;
+
+  const inventoryEndpoint = getUsageDiscoveredInventoryEndpoint();
+  const declareEndpoint = getSkillsDeclareEndpoint();
+  if (!inventoryEndpoint || !declareEndpoint) {
+    process.stderr.write(`\n  ${c.addSkillsErrorNoEndpoint}\n\n`);
+    return;
+  }
+
+  const acceptance = await confirmDisclaimerAcceptance({ ask, catalog, stdinIsTTY, preAccepted });
+  if (!acceptance.accepted) return; // confirmDisclaimerAcceptance already printed why
+
+  const inventory = await requestDiscoveredInventory(
+    { accessToken: session.accessToken },
+    { endpoint: inventoryEndpoint },
+  );
+  if (!inventory.ok) {
+    process.stderr.write(`\n  ${c.addSkillsResolveErrorIntro} ${reasonCopy(inventory.reason, c)}\n\n`);
+    return;
+  }
+
+  const candidates = inventory.skills.map((skill) => ({
+    skillId: skill.skillId,
+    skillName: skill.skillName,
+    technology: skill.technologies.join(', '),
+  }));
+  if (candidates.length === 0) {
+    process.stdout.write(`\n  ${c.addSkillsNoneMatched}\n\n`);
+    return;
+  }
+
+  const hubAccessToken = session.hubAccessToken;
+  if (!hubAccessToken) {
+    process.stderr.write(`\n  ${c.addSkillsNoHubToken}\n\n`);
+    return;
+  }
+
+  const chosen = await pickSkills({ ask, stdinIsTTY, candidates, c, input, output });
+  if (!chosen || chosen.length === 0) {
+    process.stdout.write(`\n  ${c.addSkillsNoneChosen}\n\n`);
+    return;
+  }
+
+  process.stdout.write('\n');
+  const { pending, hubSessionExpired, succeeded, declared } = await declareAll(
+    chosen, { accessToken: session.accessToken, hubAccessToken }, declareEndpoint, c,
+  );
+  if (!hubSessionExpired) {
+    printProfileBoost(succeeded, c);
+    await offerRelateToPortfolios({ ask, stdinIsTTY, declared, session, c, input, output });
+    process.stdout.write('\n');
+    return;
+  }
+
+  process.stdout.write(`\n  ${c.addSkillsHubSessionExpired}\n`);
+  const relogged = await offerRelogin({ ask, c, runLogin });
+  if (!relogged) return;
+  process.stdout.write(`  ${c.addSkillsRelaunchAfterRelogin}\n\n`);
+  const retried = await declareAll(pending, { accessToken: relogged.accessToken, hubAccessToken: relogged.hubAccessToken }, declareEndpoint, c);
+  printProfileBoost(succeeded + retried.succeeded, c);
+  await offerRelateToPortfolios({
+    ask, stdinIsTTY, declared: [...declared, ...retried.declared], session: relogged, c, input, output,
+  });
+  process.stdout.write('\n');
+}
+
+function printProfileBoost(succeeded, c) {
+  if (succeeded > 0) process.stdout.write(`  ${c.addSkillsProfileBoost}\n`);
+}
+
+// Asks the Talent whether to re-login, right there, and runs it if they say yes.
+async function offerRelogin({ ask, c, runLogin }) {
+  if (typeof runLogin !== 'function') return null;
+  const raw = String(await ask(`\n  ${c.addSkillsOfferRelogin} `)).trim();
+  if (!/^(y|yes|s|si|sí)$/i.test(raw)) {
+    process.stdout.write(`\n  ${c.addSkillsRelaunchDeclined}\n\n`);
+    return null;
+  }
+  await runLogin([], { ask });
+  const fresh = loadAuthSession();
+  if (sessionStatus(fresh) !== 'active' || !fresh.hubAccessToken) {
+    process.stdout.write(`\n  ${c.addSkillsReloginFailed}\n\n`);
+    return null;
+  }
+  return fresh;
+}
+
+module.exports = {
+  runAddSkills,
+  parseMultiIndices,
+  reasonCopy,
+  declareAll,
+  printProfileBoost,
+  offerRelateToPortfolios,
+  // Exported for src/start-add-agents.js's own relate step (ADR-041): the multi-select over the Talent's portfolios, reused verbatim.
+  pickPortfolios,
+};

package/src/stdin-ask.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const readline = require('readline');
+const { readSecretRaw, canPromptSecretly } = require('./secret-prompt');
+
+// `ask(question) => Promise<string>` factory for real stdin, used by bin/report.js to drive src/consent-flow.js's interactive disclosure.
+
+function createLineQueueAsk(writeQuestion) {
+  const queue = [];
+  let resolveNext = null;
+  let ended = false;
+
+  function pushLine(line) {
+    if (resolveNext) {
+      const resolve = resolveNext;
+      resolveNext = null;
+      resolve(line);
+    } else {
+      queue.push(line);
+    }
+  }
+
+  // Signals the stream has ended (EOF) with nothing further to give.
+  function markEnded() {
+    ended = true;
+    if (resolveNext) {
+      const resolve = resolveNext;
+      resolveNext = null;
+      resolve('');
+    }
+  }
+
+  // DELIBERATE EXCEPTION to this file's own rule ("answers arriving BEFORE ask() is called are still delivered in order" — see the test file's own name for that behaviour).
+  function drain() {
+    queue.length = 0;
+  }
+
+  function ask(question) {
+    writeQuestion(question);
+    return new Promise((resolve) => {
+      if (queue.length > 0) resolve(queue.shift());
+      else if (ended) resolve('');
+      else resolveNext = resolve;
+    });
+  }
+
+  return { ask, pushLine, markEnded, drain };
+}
+
+// `onInterrupt` (optional): a Ctrl-C (SIGINT) handler for a TTY.
+function createStdinAsk({ onInterrupt } = {}) {
+  // `rl` is re-createable (issue 102), not a `const`.
+  let rl = null;
+  let ended = false;
+  let suspending = false;
+  let currentPrompt = '';
+
+  const { ask, pushLine, markEnded, drain } = createLineQueueAsk((question) => {
+    // Long-answer wrap bug (skill-code-certification, certify agents): in a TTY, `readline` runs in terminal mode and redraws the current line on every keystroke (wrap, cursor).
+    const text = `  ${question} `;
+    const lastNewline = text.lastIndexOf('\n');
+    if (lastNewline >= 0) {
+      process.stdout.write(text.slice(0, lastNewline + 1));
+      currentPrompt = text.slice(lastNewline + 1);
+    } else {
+      currentPrompt = text;
+    }
+    if (rl) { rl.setPrompt(currentPrompt); rl.prompt(); }
+  });
+  function attach() {
+    if (rl) return;
+    rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    // The issue-088 fix, re-applied on every attach: readline must own the prompt
+    // it repaints, and a new interface does not know the old one.
+    if (currentPrompt) rl.setPrompt(currentPrompt);
+    rl.on('line', pushLine);
+    rl.on('close', () => {
+      rl = null;
+      // A `suspend()` close is intentional (the secret prompt); a real EOF is not.
+      if (!suspending) { ended = true; markEnded(); }
+    });
+    rl.on('SIGINT', onInterrupt || (() => {
+      process.stdout.write('\n');
+      if (rl) rl.close();
+      process.exit(130);
+    }));
+  }
+
+  attach();
+
+  // Releases stdin so the raw-mode secret reader can own it, WITHOUT ending the
+  // FIFO queue: buffered lines survive. Mirrors `repl-stdin.js#suspend`.
+  function suspend() {
+    if (!rl) return;
+    suspending = true;
+    const r = rl;
+    rl = null;
+    r.close();
+    suspending = false;
+  }
+  // SECRETS DO NOT ECHO (issue 102).
+  ask.secret = async (question) => {
+    if (!canPromptSecretly(process.stdin)) return ask(question);
+    process.stdout.write(`  ${question} `);
+    suspend();
+    try {
+      const value = await readSecretRaw({ input: process.stdin, output: process.stdout });
+      return value == null ? '' : value;
+    } finally {
+      // In a `finally` because a terminal left without echo is worse than the bug
+      // this replaces: re-attaching restores readline's cooked mode and its prompt.
+      attach();
+    }
+  };
+
+  ask.close = () => {
+    ended = true;
+    if (rl) { const r = rl; rl = null; r.close(); }
+    markEnded();
+  };
+  ask.suspend = suspend;
+  ask.resume = attach;
+  ask.isEnded = () => ended;
+  // See createLineQueueAsk's `drain` docblock: discards whatever is queued and unread, without ending the stream.
+  ask.drain = drain;
+  return ask;
+}
+
+module.exports = { createStdinAsk, createLineQueueAsk };

package/src/steering-extract.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { eachHumanText } = require('./transcript-turns');
+const { scrubSecrets } = require('./agent-synthesis');
+
+const MAX_EXCERPTS = 20;
+const MAX_EXCERPT_LEN = 200;
+
+const STEERING_RE =
+  /\b(no|nope|not that|don'?t|do not|instead|en vez de|en lugar de|mejor|better|change|cambia|revert|revierte|vuelve|deshaz|undo|stop|para|wrong|incorrect|incorrecto|fix|arregla|corrige|use|usa|make it|hazlo|add|añade|remove|quita|ensure|asegúrate|should|deberías|must|debes)\b/i;
+
+function makeSteeringAccumulator() {
+  let steeringTraceCount = 0;
+  const excerpts = [];
+  const seen = new Set();
+  return {
+    add(text) {
+      if (!STEERING_RE.test(text)) return;
+      steeringTraceCount += 1;
+      if (excerpts.length >= MAX_EXCERPTS) return;
+      const scrubbed = scrubSecrets(text)
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, MAX_EXCERPT_LEN);
+      if (scrubbed && !seen.has(scrubbed)) {
+        seen.add(scrubbed);
+        excerpts.push(scrubbed);
+      }
+    },
+    result() {
+      if (steeringTraceCount === 0) return null;
+      return { steeringTraceCount, redactedSteeringExcerpts: excerpts };
+    },
+  };
+}
+
+function collectSteering(env = process.env, selectedCwds = null) {
+  const acc = makeSteeringAccumulator();
+  for (const text of eachHumanText(env, { selectedCwds })) acc.add(text);
+  return acc.result();
+}
+
+module.exports = { collectSteering, makeSteeringAccumulator };

package/src/strip-internal-comments.js

@@ -0,0 +1,45 @@
+'use strict';
+
+// Our comments do not travel in the talent's shareable report (issue 098).
+
+// `<!-- … -->`, including multi-line.
+const HTML_COMMENT_RE = /<!--[\s\S]*?-->/g;
+
+// `/* … */`, the CSS and JS block form. Same verification as above.
+const BLOCK_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
+
+// A whole line that is nothing but a `//` comment.
+const LINE_COMMENT_RE = /^[ \t]*\/\/[^\n]*$/gm;
+
+// Three or more consecutive newlines (what a removed comment block leaves
+// behind) collapse to two. Never touches indentation or single blank lines.
+const BLANK_RUN_RE = /\n{3,}/g;
+
+function stripTemplateComments(html) {
+  if (typeof html !== 'string' || !html) return '';
+  return html
+    .replace(HTML_COMMENT_RE, '')
+    .replace(BLOCK_COMMENT_RE, '')
+    .replace(LINE_COMMENT_RE, '')
+    .replace(BLANK_RUN_RE, '\n\n');
+}
+
+// The patterns that make a comment an INTERNAL reference — exported so the test and this module agree on one definition instead of two.
+const INTERNAL_REFERENCE_PATTERNS = Object.freeze([
+  { label: 'issue reference', re: /\bissues?\s*#?\d{2,4}\b/i },
+  { label: 'commit hash', re: /(?<![#\w])(?=[0-9a-f]{7,40}(?![\w]))(?=[0-9a-f]*[a-f])(?=[0-9a-f]*\d)[0-9a-f]{7,40}(?![\w])/ },
+  { label: 'src/ file path', re: /\bsrc\/[a-z0-9-]+\.(?:js|html|css)\b/i },
+  { label: 'ADR reference', re: /\bADR-\d{2,3}\b/ },
+]);
+
+function findInternalReferences(text) {
+  const hay = typeof text === 'string' ? text : '';
+  const found = [];
+  for (const { label, re } of INTERNAL_REFERENCE_PATTERNS) {
+    const m = hay.match(new RegExp(re.source, re.flags.includes('g') ? re.flags : `${re.flags}g`));
+    if (m && m.length) found.push({ label, matches: [...new Set(m)] });
+  }
+  return found;
+}
+
+module.exports = { stripTemplateComments, findInternalReferences, INTERNAL_REFERENCE_PATTERNS };