shakers-cli 0.0.0-stage → 0.14.1

package/src/mcp-socials-tools.js

@@ -0,0 +1,41 @@
+'use strict';
+
+// MCP: view the talent's social links. Read-only (editing is CLI-only).
+
+const LIST_SOCIALS_SCHEMA = { type: 'object', properties: {} };
+
+function makeSocialsTools(deps = {}) {
+  const {
+    fetchSocials = (opts) => require('./socials-client').fetchSocials({}, opts),
+    loadAuthSession = require('./auth-session-store').loadAuthSession,
+    sessionStatus = require('./auth-session-store').sessionStatus,
+  } = deps;
+
+  const requireLoginSession = () => {
+    const session = loadAuthSession();
+    if (sessionStatus(session) !== 'active') {
+      throw new Error('no active Shakers session — sign in with social_signin_start (or run `shakers login`) first (list_socials is session-gated).');
+    }
+    return session;
+  };
+
+  async function listSocials() {
+    const session = requireLoginSession();
+    const res = await fetchSocials({ hubAccessToken: session.hubAccessToken });
+    if (!res.ok) return { ok: false, reason: res.reason };
+    return { ok: true, social: res.social };
+  }
+
+  return [
+    {
+      name: 'list_socials',
+      title: 'Your social links',
+      description: 'Shows the social and web links on your Shakers profile.',
+      guidance: "View the talent's social links (linkedin/github/website/twitter/instagram/facebook/dribbble/behance — null when unset). Read-only. Requires an active session.",
+      inputSchema: LIST_SOCIALS_SCHEMA,
+      handler: listSocials,
+    },
+  ];
+}
+
+module.exports = { makeSocialsTools, LIST_SOCIALS_SCHEMA };

package/src/memory-structure-detector.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getHomeDir } = require('./env-paths');
+
+// Deterministic (no-LLM) memory STRUCTURE detector (talents-ai-score, issue 016 / ADR-013-014).
+
+const MAX_FILE_BYTES = 2_000_000; // safety cap: never read a pathologically huge file
+const MAX_IMPORT_DEPTH = 5; // mirrors Claude Code's own documented import-hop limit
+const MAX_FILES_VISITED = 100; // safety cap against import fan-out/cycles
+
+// Claude Code's `@path/to/file` import syntax: an `@` at the start of a line or preceded by whitespace, followed by a non-space path.
+const IMPORT_RE = /(?:^|\s)@(\S+)/gm;
+const HEADER_RE = /^#{1,6}\s+\S/gm;
+
+function safeReadText(file) {
+  try {
+    const st = fs.statSync(file);
+    if (!st.isFile() || st.size > MAX_FILE_BYTES) return null;
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function countMatches(re, text) {
+  const matches = text.match(re);
+  return matches ? matches.length : 0;
+}
+
+function extractImportPaths(text) {
+  const paths = [];
+  const re = new RegExp(IMPORT_RE);
+  let m;
+  while ((m = re.exec(text)) !== null) paths.push(m[1]);
+  return paths;
+}
+
+function resolveImportPath(importPath, fromDir, home) {
+  if (importPath.startsWith('~/')) return path.join(home, importPath.slice(2));
+  return path.resolve(fromDir, importPath);
+}
+
+// Recursively walks `@imports` starting at `file`.
+function walkImports(file, home, depth, visited, budget) {
+  if (depth > MAX_IMPORT_DEPTH || visited.has(file) || budget.files >= MAX_FILES_VISITED) {
+    return { maxDepth: depth - 1, importCount: 0 };
+  }
+  visited.add(file);
+  budget.files += 1;
+
+  const text = safeReadText(file);
+  if (text === null) return { maxDepth: depth - 1, importCount: 0 };
+
+  const importPaths = extractImportPaths(text);
+  if (importPaths.length === 0) return { maxDepth: depth, importCount: 0 };
+
+  let maxDepth = depth;
+  let importCount = importPaths.length;
+  const fromDir = path.dirname(file);
+  for (const p of importPaths) {
+    const resolved = resolveImportPath(p, fromDir, home);
+    const sub = walkImports(resolved, home, depth + 1, visited, budget);
+    maxDepth = Math.max(maxDepth, sub.maxDepth);
+    importCount += sub.importCount;
+  }
+  return { maxDepth, importCount };
+}
+
+function analyzeFile(file, home) {
+  const text = safeReadText(file);
+  if (text === null) return null;
+  const sections = countMatches(HEADER_RE, text);
+  const sizeBytes = Buffer.byteLength(text, 'utf8');
+  const { maxDepth, importCount } = walkImports(file, home, 1, new Set(), { files: 0 });
+  return { sizeBytes, sections, imports: importCount, depth: maxDepth };
+}
+
+function knownContextFiles(root, home) {
+  return [
+    { id: 'CLAUDE.md', file: path.join(root, 'CLAUDE.md') },
+    { id: 'CLAUDE.md (home)', file: path.join(home, '.claude', 'CLAUDE.md') },
+    { id: 'AGENTS.md', file: path.join(root, 'AGENTS.md') },
+    { id: 'GEMINI.md', file: path.join(root, 'GEMINI.md') },
+  ];
+}
+
+// Deterministic (no-LLM) memory structure analysis, scoped to known context files (project ∪ home).
+function analyzeMemoryStructure(root) {
+  const home = getHomeDir();
+  const files = [];
+  let totalImports = 0;
+  let maxDepth = 0;
+
+  for (const { id, file } of knownContextFiles(root, home)) {
+    const analysis = analyzeFile(file, home);
+    if (!analysis) continue;
+    files.push({ id, ...analysis });
+    totalImports += analysis.imports;
+    maxDepth = Math.max(maxDepth, analysis.depth);
+  }
+
+  // "layered" (anidada/por capas) means a REAL import chain — an import that itself imports further files — not just a single flat `@import`.
+  return { files, totalImports, maxDepth, layered: maxDepth > 2 };
+}
+
+module.exports = { analyzeMemoryStructure };

package/src/model-call-record.js

@@ -0,0 +1,198 @@
+'use strict';
+
+// What happened with each model call, written down (talents-ai-score, issue 109).
+
+// The three keys.
+const MODEL_CALL = Object.freeze({
+  SYNTHESIS: 'agentSynthesis',
+  EVALUATION: 'agentEvaluation',
+  ROADMAP: 'roadmapPersonalization',
+});
+
+const REASON = Object.freeze({
+  // ok:true
+  OK: 'ok',
+  // ok:true AND INCOMPLETE (2026-08-03, from a real incident).
+  OK_PARTIAL: 'ok-partial',
+  // ok:null — never attempted, and NOT a failure
+  NO_AGENTS: 'no-agents',
+  NO_ENDPOINT: 'no-endpoint-configured',
+  MAX_TIER: 'max-tier',
+  NOT_APPLICABLE: 'not-applicable',
+  NO_CONSENT: 'no-consent',
+  // ok:false — attempted, and something was lost
+  TIMEOUT: 'timeout',
+  NETWORK: 'network-error',
+  INVALID_URL: 'invalid-endpoint-url',
+  HTTP: 'http-error',
+  MALFORMED_JSON: 'malformed-json',
+  UNEXPECTED_SHAPE: 'unexpected-shape',
+  LOCAL_ERROR: 'local-error',
+});
+
+// The reasons that mean the call produced usable data (`ok: true`).
+const SUCCESS_REASONS = new Set([REASON.OK, REASON.OK_PARTIAL]);
+
+// "Didn't apply" — the reasons that produce `ok: null`.
+const SKIP_REASONS = new Set([
+  REASON.NO_AGENTS,
+  REASON.NO_ENDPOINT,
+  REASON.MAX_TIER,
+  REASON.NOT_APPLICABLE,
+  REASON.NO_CONSENT,
+]);
+
+const FAILURE_REASONS = new Set([
+  REASON.TIMEOUT,
+  REASON.NETWORK,
+  REASON.INVALID_URL,
+  REASON.HTTP,
+  REASON.MALFORMED_JSON,
+  REASON.UNEXPECTED_SHAPE,
+  REASON.LOCAL_ERROR,
+]);
+
+// The rejection `.kind` tags `src/backend-request.js` attaches, mapped onto this vocabulary.
+function classifyChainError(e) {
+  const kind = e && e.kind;
+  if (kind === 'timeout') return REASON.TIMEOUT;
+  if (kind === 'network-error') return REASON.NETWORK;
+  if (kind === 'invalid-url') return REASON.INVALID_URL;
+  if (kind === 'no-endpoint') return REASON.NO_ENDPOINT;
+  return REASON.LOCAL_ERROR;
+}
+
+// The canonical record.
+function record({ attemptedAt, ok, reason, status = null, backend = null, elapsedMs = null, timeoutMs = null, hops = [], omitted = [] }) {
+  return {
+    attemptedAt: attemptedAt || null,
+    ok,
+    reason,
+    status: typeof status === 'number' ? status : null,
+    backend: backend || null,
+    elapsedMs: typeof elapsedMs === 'number' ? elapsedMs : null,
+    timeoutMs: typeof timeoutMs === 'number' ? timeoutMs : null,
+    hops: Array.isArray(hops) ? hops : [],
+    // What the call did NOT cover, by name.
+    omitted: Array.isArray(omitted) ? omitted.filter((n) => typeof n === 'string' && n) : [],
+  };
+}
+
+// A call that never went out.
+function skipped(reason) {
+  return record({ attemptedAt: null, ok: null, reason: reason || REASON.NOT_APPLICABLE });
+}
+
+// A failure that happened BEFORE the wire (building the request threw: a file that can't be read, a parse that blew up).
+function failedLocally(reason = REASON.LOCAL_ERROR) {
+  return record({ attemptedAt: new Date().toISOString(), ok: false, reason });
+}
+
+// The one-shot reporter each client module uses.
+function reporterFor(onOutcome, { timeoutMs = null } = {}) {
+  const attemptedAt = new Date().toISOString();
+  const startedHr = process.hrtime.bigint();
+  const hops = [];
+  let settled = false;
+
+  const emit = (built) => {
+    if (settled) return null;
+    settled = true;
+    if (typeof onOutcome === 'function') onOutcome(built);
+    return built;
+  };
+  const elapsed = () => Number((process.hrtime.bigint() - startedHr) / 1000000n);
+
+  return {
+    // Handed to `requestBackend` as `trace`.
+    hops,
+    skip(reason) {
+      return emit(skipped(reason));
+    },
+    fail(reason, { status = null, backend = null } = {}) {
+      return emit(record({ attemptedAt, ok: false, reason, status, backend, elapsedMs: elapsed(), timeoutMs, hops }));
+    },
+    failFromError(e) {
+      return this.fail(classifyChainError(e));
+    },
+    // `omitted` non-empty flips the reason to `ok-partial` and NOT `ok` — the one decision that stops a partial answer from being recorded as a clean run.
+    succeed({ status = null, backend = null, omitted = [] } = {}) {
+      const left = Array.isArray(omitted) ? omitted.filter((n) => typeof n === 'string' && n) : [];
+      return emit(record({
+        attemptedAt,
+        ok: true,
+        reason: left.length ? REASON.OK_PARTIAL : REASON.OK,
+        status,
+        backend,
+        elapsedMs: elapsed(),
+        timeoutMs,
+        hops,
+        omitted: left,
+      }));
+    },
+  };
+}
+
+// Attaches a record to the report under its call key.
+function attachModelCall(report, key, built) {
+  if (!report || typeof report !== 'object' || !key) return built;
+  if (!report.modelCalls || typeof report.modelCalls !== 'object') report.modelCalls = {};
+  report.modelCalls[key] = built;
+  return built;
+}
+
+function modelCall(report, key) {
+  const calls = report && report.modelCalls;
+  return calls && typeof calls === 'object' ? calls[key] || null : null;
+}
+
+// The two predicates the render layer is allowed to ask.
+function callFailed(report, key) {
+  const c = modelCall(report, key);
+  return !!c && c.ok === false;
+}
+
+function callSucceeded(report, key) {
+  const c = modelCall(report, key);
+  return !!c && c.ok === true;
+}
+
+// The call worked AND left something out.
+function callPartial(report, key) {
+  const c = modelCall(report, key);
+  return !!c && c.ok === true && Array.isArray(c.omitted) && c.omitted.length > 0;
+}
+
+// THE CALL LOST TIME TO A DEADLINE — and this is NOT `reason === TIMEOUT` (issue 116, found by measuring, not by reading).
+function callTimedOut(report, key) {
+  const c = modelCall(report, key);
+  if (!c || c.ok !== false) return false;
+  if (c.reason === REASON.TIMEOUT) return true;
+  return Array.isArray(c.hops) && c.hops.some((h) => h && h.kind === REASON.TIMEOUT);
+}
+
+// The names the call left out, for the surface that names them. `[]` when the run
+// was complete, so a caller never has to null-check before iterating.
+function omittedByCall(report, key) {
+  const c = modelCall(report, key);
+  return c && Array.isArray(c.omitted) ? c.omitted : [];
+}
+
+module.exports = {
+  MODEL_CALL,
+  REASON,
+  SKIP_REASONS,
+  FAILURE_REASONS,
+  SUCCESS_REASONS,
+  classifyChainError,
+  skipped,
+  failedLocally,
+  reporterFor,
+  attachModelCall,
+  modelCall,
+  callFailed,
+  callSucceeded,
+  callPartial,
+  callTimedOut,
+  omittedByCall,
+};

package/src/onboarding-availability.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const { loadAuthSession, sessionStatus } = require('./auth-session-store');
+const { getOnboardingStatusEndpoint } = require('./config');
+const { requestOnboardingStatus } = require('./onboarding-status-client');
+
+async function checkOnboardingCompleted({
+  env = process.env,
+  session = null,
+  loadSession = loadAuthSession,
+  endpointGetter = getOnboardingStatusEndpoint,
+  fetchStatus = requestOnboardingStatus,
+  timeoutMs,
+} = {}) {
+  const active = session || loadSession();
+  if (sessionStatus(active) !== 'active') return false;
+  const endpoint = endpointGetter(env);
+  if (!endpoint) return false;
+  const res = await fetchStatus(
+    { accessToken: active.accessToken },
+    timeoutMs ? { endpoint, timeoutMs } : { endpoint },
+  );
+  return res.ok ? res.completed === true : false;
+}
+
+module.exports = { checkOnboardingCompleted };