shakers-cli 0.0.0-stage → 0.14.0

package/src/report-store.js

@@ -0,0 +1,226 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { pathToFileURL } = require('url');
+
+const { getConfigDir } = require('./config-dir');
+const { renderSheet } = require('./render-sheet');
+const { reportGateForIdentity } = require('./report-gating');
+
+const SCHEMA_VERSION = 2;
+
+function configDir() {
+  return getConfigDir(process.env);
+}
+function statePath() {
+  return path.join(configDir(), 'report-state.json');
+}
+
+// Stable, filesystem-safe per-project file name derived from the absolute path.
+function projectSlug(absRoot) {
+  return crypto.createHash('sha1').update(String(absRoot)).digest('hex').slice(0, 12);
+}
+function htmlPathFor(absRoot) {
+  return path.join(configDir(), `report-${projectSlug(path.resolve(absRoot))}.html`);
+}
+
+// A real file:// URL (handles spaces, Windows drive letters, etc.) so the CLI
+// can print a link the talent can click/paste to open the report.
+function fileUrl(p) {
+  return pathToFileURL(p).href;
+}
+
+function freshState() {
+  return { schemaVersion: SCHEMA_VERSION, updatedAt: null, projects: {} };
+}
+
+function migrateFromV1(parsed) {
+  const projects = {};
+  const legacyFootprints = parsed && parsed.footprints && typeof parsed.footprints === 'object'
+    ? parsed.footprints
+    : {};
+  for (const [absRoot, fp] of Object.entries(legacyFootprints)) {
+    projects[absRoot] = {
+      root: (fp && fp.root) || absRoot,
+      updatedAt: (fp && fp.generatedAt) || null,
+      footprint: fp
+        ? { generatedAt: fp.generatedAt || null, report: fp.report, maturity: fp.maturity }
+        : null,
+      certifications: {},
+    };
+  }
+  return { schemaVersion: SCHEMA_VERSION, updatedAt: (parsed && parsed.updatedAt) || null, projects };
+}
+
+function loadState() {
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(statePath(), 'utf8'));
+  } catch {
+    return freshState();
+  }
+  if (parsed && parsed.schemaVersion === SCHEMA_VERSION && parsed.projects && typeof parsed.projects === 'object') {
+    return { schemaVersion: SCHEMA_VERSION, updatedAt: parsed.updatedAt || null, projects: parsed.projects };
+  }
+  // Any older / unknown shape (v1 global model, or garbage) -> migrate what we can.
+  return migrateFromV1(parsed);
+}
+
+function saveState(state) {
+  fs.mkdirSync(configDir(), { recursive: true });
+  fs.writeFileSync(statePath(), JSON.stringify(state, null, 2));
+}
+
+function getOrCreateProject(state, absRoot) {
+  if (!state.projects[absRoot]) {
+    state.projects[absRoot] = {
+      root: absRoot,
+      updatedAt: null,
+      footprint: null,
+      certifications: {},
+      backendAcceptance: {},
+    };
+  }
+  // Backward-compat: a project persisted before the two-backend chain
+  // existed (talents-ai-score, ADR-020/021).
+  if (!state.projects[absRoot].backendAcceptance) {
+    state.projects[absRoot].backendAcceptance = {};
+  }
+  return state.projects[absRoot];
+}
+
+/* ---------- rendering a SINGLE project's document ---------- */
+
+function renderProjectHtml(project, lang, gate) {
+  return renderSheet(project, lang, gate);
+}
+
+/* ---------- persist (state only) + materialize (render HTML) ---------- */
+// ADR-016 split: `footprint` and `certify` now PERSIST state only (no HTML file, no printed link).
+
+function stampAndSaveState(state, absRoot) {
+  state.schemaVersion = SCHEMA_VERSION;
+  const now = new Date().toISOString();
+  state.updatedAt = now;
+  state.projects[absRoot].updatedAt = now;
+  saveState(state);
+  return { statePath: statePath(), stateDir: configDir() };
+}
+
+function writeProjectHtml(project, absRoot, lang, gate) {
+  const html = renderProjectHtml(project, lang, gate);
+  fs.mkdirSync(configDir(), { recursive: true });
+  const p = htmlPathFor(absRoot);
+  fs.writeFileSync(p, html);
+  return { htmlPath: p, fileUrl: fileUrl(p) };
+}
+
+// Persist THIS project's footprint into report-state.json (keyed by absolute project path).
+function persistFootprint({ root, report, maturity }) {
+  const absRoot = path.resolve(root || process.cwd());
+  const state = loadState();
+  const project = getOrCreateProject(state, absRoot);
+  project.footprint = {
+    generatedAt: (report && report.generatedAt) || new Date().toISOString(),
+    report,
+    maturity,
+  };
+  return stampAndSaveState(state, absRoot);
+}
+
+function loadAgentClassifications(root) {
+  const absRoot = path.resolve(root || process.cwd());
+  const state = loadState();
+  const project = state.projects && state.projects[absRoot];
+  const evaluation = project && project.footprint && project.footprint.report && project.footprint.report.agentEvaluation;
+  const evaluations = evaluation && Array.isArray(evaluation.evaluations) ? evaluation.evaluations : [];
+  const byName = {};
+  for (const e of evaluations) {
+    if (e && typeof e.name === 'string' && e.name && e.classification) {
+      byName[e.name] = e.classification;
+    }
+  }
+  return byName;
+}
+
+function recordBackendAcceptance({ root, kind, backend }) {
+  if (!kind || !backend) return null;
+  const absRoot = path.resolve(root || process.cwd());
+  const state = loadState();
+  const project = getOrCreateProject(state, absRoot);
+  project.backendAcceptance[kind] = { backend, at: new Date().toISOString() };
+  return stampAndSaveState(state, absRoot);
+}
+
+function loadFootprint({ root } = {}) {
+  const absRoot = path.resolve(root || process.cwd());
+  const state = loadState();
+  const project = state.projects && state.projects[absRoot];
+  const fp = project && project.footprint;
+  return fp && fp.report ? { report: fp.report, maturity: fp.maturity } : null;
+}
+
+// The gate of `materializeProjectReport`, as a NAMED TABLE rather than an inlined chain of `&&`s — and the table IS the inventory.
+const RENDERED_DATA = {
+  footprint: (p) => !!(p.footprint && p.footprint.report),
+  certifications: (p) => !!(p.certifications && Object.keys(p.certifications).length),
+};
+
+function hasRenderableData(project) {
+  if (!project) return false;
+  return Object.values(RENDERED_DATA).some((has) => has(project));
+}
+
+// Materialize (render + write) THIS project's cumulative HTML from persisted state, and return its path + file:// URL.
+function materializeProjectReport({ root, lang }) {
+  const absRoot = path.resolve(root || process.cwd());
+  const state = loadState();
+  const project = state.projects[absRoot];
+  if (!hasRenderableData(project)) return { hasData: false };
+  // issue 123 / ADR-044: the shareable HTML is gated by identity AT GENERATION TIME — this is the moment the `report` command produces the file, so this is where the gate is resolved.
+  const gate = reportGateForIdentity();
+  return { hasData: true, ...writeProjectHtml(project, absRoot, lang, gate) };
+}
+
+// `upsertFootprint` AND `upsertCertification` WERE HERE, and ADR-035 retired them.
+
+function certKey(item) {
+  if (item && item.skillId != null) return `id:${item.skillId}`;
+  const name = (item && item.skillName) || '';
+  const tech = (item && item.technology) || '';
+  return `nt:${name}::${tech}`;
+}
+
+// Upsert each certified Skill from this run into THIS PROJECT's report (keyed by Skill id within the project).
+function persistCertification({ root, items }) {
+  const absRoot = path.resolve(root || process.cwd());
+  const list = Array.isArray(items) ? items.filter((i) => i && (i.skillId != null || i.skillName)) : [];
+  const state = loadState();
+  const project = getOrCreateProject(state, absRoot);
+  const now = new Date().toISOString();
+  for (const item of list) {
+    project.certifications[certKey(item)] = { generatedAt: now, item };
+  }
+  return stampAndSaveState(state, absRoot);
+}
+
+module.exports = {
+  configDir,
+  statePath,
+  htmlPathFor,
+  projectSlug,
+  fileUrl,
+  loadState,
+  saveState,
+  renderProjectHtml,
+  persistFootprint,
+  persistCertification,
+  loadAgentClassifications,
+  loadFootprint,
+  recordBackendAcceptance,
+  materializeProjectReport,
+  certKey,
+  SCHEMA_VERSION,
+};

package/src/report-theme.js

@@ -0,0 +1,177 @@
+'use strict';
+
+function esc(s) {
+  return String(s == null ? '' : s).replace(/[&<>"']/g, (ch) => ({
+    '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
+  }[ch]));
+}
+
+/* ---------- design tokens (Shakers "Nexia", light-only, WHITE bg) ---------- */
+
+const TOKENS_CSS = `
+  :root{
+    /* Layer 1 — brand primitives (subset used), verbatim from the DS */
+    --ds-teal-50:#e2f2f0; --ds-teal-100:#c5e5e1; --ds-teal-300:#51b1a5;
+    --ds-teal-400:#269787; --ds-teal-500:#0e7d69; --ds-teal-600:#0b5a4c;
+    --ds-teal-700:#08473c; --ds-teal-800:#05342c; --ds-teal-900:#03211c;
+    --ds-lime-200:#f5ff96; --ds-lime-500:#d8e637; --ds-lime-600:#b0bd2d;
+    --ds-zinc-50:#fafafa; --ds-zinc-100:#f4f4f5; --ds-zinc-200:#e4e4e7;
+    --ds-zinc-300:#d4d4d8; --ds-zinc-400:#a1a1aa; --ds-zinc-500:#71717a;
+    --ds-zinc-600:#52525b; --ds-zinc-700:#3f3f46; --ds-zinc-800:#27272a; --ds-zinc-900:#18181b;
+    --ds-zinc-950:#09090b; --ds-white:#ffffff;
+    /* DS status palette (design-spec/tokens.css) — used for score bands and
+       the "partial sample" warning; functional status colors, not invented. */
+    --ds-success:#059669; --ds-success-fg:#ecfdf5;
+    --ds-warning:#f59e0b; --ds-warning-fg:#fffdf5;
+    --ds-destructive:#e11d48; --ds-destructive-fg:#fef2f2;
+
+    /* Radii ("Border Radius" frame) */
+    --r-sm:6px; --r-md:8px; --r-lg:10px; --r-xl:14px; --r-full:9999px;
+    /* Shadows (shadcn upstream) */
+    --shadow-sm:0 1px 3px 0 rgb(0 0 0 / .1), 0 1px 2px -1px rgb(0 0 0 / .1);
+    --shadow-md:0 1px 3px 0 rgb(0 0 0 / .1), 0 2px 4px -1px rgb(0 0 0 / .1);
+    --shadow-lg:0 1px 3px 0 rgb(0 0 0 / .1), 0 4px 6px -1px rgb(0 0 0 / .1);
+
+    /* Inter with a system fallback (no @font-face, no network): if Inter isn't
+       installed it degrades to the DS's own fallback stack. */
+    --font-sans:"Inter",ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,
+      "Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,
+      "Apple Color Emoji","Segoe UI Emoji";
+    --font-mono:ui-monospace,"SF Mono","Cascadia Code","JetBrains Mono",Menlo,Consolas,monospace;
+
+    /* Layer 2 — semantic (light theme, the ONLY theme). Background is WHITE
+       (the DS's --color-background), priority #1. */
+    --bg:var(--ds-white);
+    --surface:var(--ds-white);
+    --fg:var(--ds-zinc-900);
+    --muted:var(--ds-zinc-700);
+    /* zinc-600 (not zinc-500) for caption/label text: clears WCAG AA on white. */
+    --faint:var(--ds-zinc-600);
+    --border:var(--ds-zinc-200);
+    --primary:var(--ds-teal-800);
+    --primary-fg:var(--ds-zinc-50);
+    --secondary:var(--ds-teal-50);
+    --secondary-fg:var(--ds-teal-600);
+    --emphasis:var(--ds-teal-500);
+    --emphasis-strong:var(--ds-teal-600);
+    --accent-lime:var(--ds-lime-500);
+    --accent-lime-fg:var(--ds-teal-800);
+    /* Model chip: an opaque lime tint over the surface, dark teal text. */
+    --model-bg:color-mix(in srgb,var(--ds-lime-500) 26%, var(--surface));
+    --model-fg:var(--ds-teal-800);
+    --off:var(--ds-zinc-300);
+    --track:var(--ds-zinc-100);
+    --ring:var(--ds-teal-500);
+    /* Score bands (certification): DS status colors. */
+    --band-high-bg:var(--ds-success); --band-high-fg:var(--ds-success-fg);
+    --band-mid-bg:var(--ds-warning); --band-mid-fg:var(--ds-warning-fg);
+    --band-low-bg:var(--ds-destructive); --band-low-fg:var(--ds-destructive-fg);
+  }
+`;
+
+/* ---------- shared base + primitives (used by every report) ---------- */
+
+const BASE_CSS = `
+  *{box-sizing:border-box}
+  html{color-scheme:light}
+  body{margin:0;background:var(--bg);color:var(--fg);
+    font-family:var(--font-sans);line-height:1.45;
+    -webkit-font-smoothing:antialiased;text-rendering:optimizeLegibility;
+    padding:40px 20px 64px;}
+  .wrap{max-width:840px;margin:0 auto;overflow-x:clip}
+  .card{background:var(--surface);border:1px solid var(--border);
+    border-radius:var(--r-lg);box-shadow:var(--shadow-sm)}
+
+  /* Header */
+  header{margin-bottom:24px}
+  .badge{display:inline-flex;align-items:center;gap:8px;
+    background:var(--secondary);color:var(--secondary-fg);
+    font-size:12px;font-weight:600;letter-spacing:.02em;
+    padding:5px 12px;border-radius:var(--r-full)}
+  .badge .spark{width:7px;height:7px;border-radius:50%;background:var(--emphasis)}
+  h1{font-size:clamp(28px,5vw,36px);font-weight:700;letter-spacing:-.02em;
+    line-height:1.15;margin:16px 0 6px}
+  .sub{color:var(--muted);font-size:16px;margin:0}
+
+  /* Section scaffolding */
+  section{margin-bottom:24px}
+  .h2{font-size:13px;font-weight:600;letter-spacing:.06em;text-transform:uppercase;
+    color:var(--faint);margin:0 0 12px 2px}
+
+  /* Chips */
+  .chips{display:flex;flex-wrap:wrap;gap:6px}
+  .chip{font-size:11px;font-weight:500;letter-spacing:.02em;color:var(--secondary-fg);
+    background:var(--secondary);padding:3px 10px;border-radius:var(--r-full);
+    flex:none;white-space:nowrap}
+  .chip.empty{background:transparent;color:var(--faint);padding-left:0}
+
+  /* Footer */
+  footer{margin-top:28px;color:var(--faint);font-size:12.5px;line-height:1.55}
+  .priv{display:flex;gap:12px;padding:16px 18px;border-radius:var(--r-lg);
+    background:var(--secondary);color:var(--secondary-fg);margin-bottom:16px}
+  .priv .lock{flex:none;font-size:16px;line-height:1.4}
+  .meta-line{font-family:var(--font-mono);font-size:11.5px}
+  .meta-line code{color:var(--emphasis-strong);font-weight:600}
+  details{margin-top:14px}
+  details summary{cursor:pointer;color:var(--muted);font-weight:500;
+    padding:8px 0;user-select:none}
+  details summary:hover{color:var(--fg)}
+  pre{background:var(--bg);border:1px solid var(--border);border-radius:var(--r-md);
+    padding:14px;overflow:auto;font-family:var(--font-mono);font-size:11.5px;
+    color:var(--muted);max-height:300px}
+
+  a:focus-visible,summary:focus-visible{outline:2px solid var(--ring);outline-offset:2px}
+
+  @media (prefers-reduced-motion:reduce){
+    *{animation:none!important;transition:none!important}
+  }
+`;
+
+// Generic, zero-network clipboard helper shared by every report.
+const COPY_SCRIPT = `
+  (function(){
+    function fallbackCopy(text){
+      var ta=document.createElement('textarea');ta.value=text;ta.setAttribute('readonly','');
+      ta.style.position='fixed';ta.style.opacity='0';document.body.appendChild(ta);ta.focus();ta.select();
+      try{document.execCommand('copy');}catch(e){}document.body.removeChild(ta);
+    }
+    document.querySelectorAll('[data-copy-target]').forEach(function(btn){
+      btn.addEventListener('click',function(){
+        var target=document.getElementById(btn.getAttribute('data-copy-target'));
+        if(!target)return;var text=target.textContent;
+        var showCopied=function(){
+          var original=btn.getAttribute('data-original-label')||btn.textContent;
+          btn.setAttribute('data-original-label',original);
+          btn.textContent=btn.getAttribute('data-copied-label')||original;
+          btn.classList.add('copied');
+          setTimeout(function(){btn.textContent=original;btn.classList.remove('copied');},1800);
+        };
+        if(navigator.clipboard&&navigator.clipboard.writeText){
+          navigator.clipboard.writeText(text).then(showCopied,function(){fallbackCopy(text);showCopied();});
+        }else{fallbackCopy(text);showCopied();}
+      });
+    });
+  })();
+`;
+
+// Assembles a full, self-contained HTML document from the shared theme plus a report's own component CSS, body markup, and (optional) extra script.
+function renderDocument({ lang, title, componentCss = '', body, script = '' }) {
+  const scriptTag = (COPY_SCRIPT + '\n' + script).trim();
+  return `<!DOCTYPE html>
+<html lang="${esc(lang)}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc(title)}</title>
+<style>${TOKENS_CSS}${BASE_CSS}${componentCss}</style>
+</head>
+<body>
+<div class="wrap">
+${body}
+</div>
+<script>${scriptTag}</script>
+</body>
+</html>`;
+}
+
+module.exports = { esc, renderDocument, TOKENS_CSS, BASE_CSS, COPY_SCRIPT };

package/src/report-view-client.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const { postJsonWithTimeout } = require('./backend-request');
+
+const DEFAULT_TIMEOUT_MS = 20000;
+
+function parseJson(raw) {
+  try {
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+
+function authHeaders({ accessToken } = {}) {
+  const headers = {};
+  if (typeof accessToken === 'string' && accessToken) headers.Authorization = `Bearer ${accessToken}`;
+  return headers;
+}
+
+async function requestUsageReport({ accessToken } = {}, { endpoint, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+
+  let res;
+  try {
+    res = await postJsonWithTimeout(endpoint, null, timeoutMs, 'GET', null, authHeaders({ accessToken }));
+  } catch (e) {
+    return { ok: false, reason: (e && e.kind) || 'network-error' };
+  }
+
+  if (res.status < 200 || res.status >= 300) {
+    return { ok: false, reason: `http-${res.status}` };
+  }
+
+  const json = parseJson(res.raw);
+  const data = json && typeof json === 'object' ? json.data : null;
+  if (!data || typeof data !== 'object') return { ok: false, reason: 'bad-response' };
+
+  return {
+    ok: true,
+    report: data.report && typeof data.report === 'object' ? data.report : null,
+    fluency: data.fluency && typeof data.fluency === 'object' ? data.fluency : null,
+    interactionQuality:
+      data.interactionQuality && typeof data.interactionQuality === 'object'
+        ? data.interactionQuality
+        : null,
+  };
+}
+
+module.exports = { requestUsageReport };

package/src/reveal-output.js

@@ -0,0 +1,29 @@
+'use strict';
+
+// Shared, reusable output reveal for the NEW talent commands: buffer the human
+// render and type it out with the report's typewriter pacing (bounded by
+// `maxTotalMs`). ONE place, so every new command animates consistently.
+//
+// The LOADER stays live: on a TTY `io.withProgress` animates on stderr during the
+// fetch; only the post-fetch RENDER is buffered here and revealed afterwards.
+//
+// GATE (reused from the typewriter, not reinvented): no animation in `--json`
+// (machine output), in an interactive setter (live prompts), off a TTY, or under
+// NO_ANIMATION — in those cases writes are passed straight through.
+
+const { typeOut, revealEnabled } = require('./typewriter');
+
+// Returns `{ write, finish }`. When animating, `write` buffers and `finish`
+// types the buffer out; otherwise `write` passes through and `finish` is a no-op.
+function makeRevealSink({ json = false, interactive = false, out = null, stream = process.stdout, env = process.env, sleep } = {}) {
+  const passthrough = out || ((s) => { if (stream && typeof stream.write === 'function') stream.write(s); });
+  const animating = !json && !interactive && !out && revealEnabled({ stream, env });
+  if (!animating) return { write: passthrough, finish: async () => {} };
+  let buf = '';
+  return {
+    write: (s) => { buf += s; },
+    finish: async () => { if (buf) await typeOut(buf, { stream, ...(sleep ? { sleep } : {}) }); },
+  };
+}
+
+module.exports = { makeRevealSink };