shakers-cli 0.0.0-stage → 0.14.1

package/src/authorship.js

@@ -0,0 +1,204 @@
+'use strict';
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+
+// Git AUTHORSHIP + provenance for the certify phase (skill-code-certification, ADR-017).
+
+const { takePrefetchedGitLog } = require('./git-log-prefetch');
+
+const GIT_TIMEOUT_MS = 15000;
+const SHORT_SHA_LEN = 10;
+
+const AUTHORSHIP_LOG_ARGS = ['log', '--no-merges', '--pretty=format:\x01%ae\x1f%at', '--name-only'];
+
+function runGit(root, args) {
+  try {
+    return execFileSync('git', ['-C', root, ...args], {
+      encoding: 'utf8',
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      maxBuffer: 64 * 1024 * 1024,
+    });
+  } catch {
+    return null;
+  }
+}
+
+// True only inside a real work tree. Everything else (no git, bare repo, not a
+// repo) is treated as "cannot attribute" upstream.
+function isGitRepo(root) {
+  return runGit(root, ['rev-parse', '--is-inside-work-tree']) !== null;
+}
+
+// Repo identity for the evidence record.
+function getRepository(root) {
+  const remote = runGit(root, ['config', '--get', 'remote.origin.url']);
+  if (remote && remote.trim()) return normalizeRemote(remote.trim());
+  const top = runGit(root, ['rev-parse', '--show-toplevel']);
+  if (top && top.trim()) return path.basename(top.trim());
+  return null;
+}
+
+function normalizeRemote(url) {
+  // `git@host:owner/repo.git` | `https://[token@]host/owner/repo.git` ->
+  // `host/owner/repo`. Any userinfo (a token/password) is dropped, never kept.
+  let s = url.replace(/\.git$/, '');
+  const scp = s.match(/^[^@]+@([^:]+):(.+)$/); // scp-like ssh
+  if (scp) return `${scp[1]}/${scp[2]}`;
+  try {
+    const u = new URL(s);
+    return `${u.host}${u.pathname}`.replace(/\/+$/, '');
+  } catch {
+    return s;
+  }
+}
+
+// `<root-commit>..<HEAD>` short shas over the current branch. `null` when the
+// history can't be read (e.g. a repo with no commits yet).
+function getCommitRange(root) {
+  const head = runGit(root, ['rev-parse', `--short=${SHORT_SHA_LEN}`, 'HEAD']);
+  if (!head || !head.trim()) return null;
+  const roots = runGit(root, ['rev-list', '--max-parents=0', 'HEAD']);
+  const firstFull = roots && roots.trim() ? roots.trim().split('\n').pop().trim() : null;
+  if (!firstFull) return head.trim();
+  const first = runGit(root, ['rev-parse', `--short=${SHORT_SHA_LEN}`, firstFull]);
+  const firstShort = first && first.trim() ? first.trim() : firstFull.slice(0, SHORT_SHA_LEN);
+  return `${firstShort}..${head.trim()}`;
+}
+
+// The path git sees for a file is repo-relative; the sampler's paths are relative to `root`, which may be a SUBDIR of the repo.
+function getRootPrefix(root) {
+  const prefix = runGit(root, ['rev-parse', '--show-prefix']);
+  return prefix && prefix.trim() ? prefix.trim().replace(/\/+$/, '') : '';
+}
+
+function buildPathIndex(root) {
+  const authorsByPath = new Map();
+  const timeByPath = new Map();
+  const prefetched = takePrefetchedGitLog(root, AUTHORSHIP_LOG_ARGS);
+  const log = prefetched !== undefined ? prefetched : runGit(root, AUTHORSHIP_LOG_ARGS);
+  if (log === null) return { authorsByPath, timeByPath };
+
+  let currentEmail = null;
+  let currentTime = null;
+  for (const rawLine of log.split('\n')) {
+    if (rawLine.startsWith('\x01')) {
+      const [email, atRaw] = rawLine.slice(1).split('\x1f');
+      currentEmail = String(email || '').trim().toLowerCase();
+      const ts = Number.parseInt(atRaw, 10);
+      currentTime = Number.isFinite(ts) ? ts : null;
+      continue;
+    }
+    const file = rawLine.trim();
+    if (!file || currentEmail === null) continue;
+    let set = authorsByPath.get(file);
+    if (!set) {
+      set = new Set();
+      authorsByPath.set(file, set);
+    }
+    set.add(currentEmail);
+    if (currentTime !== null) {
+      const prev = timeByPath.get(file);
+      if (prev === undefined || currentTime > prev) {
+        timeByPath.set(file, currentTime);
+      }
+    }
+  }
+  return { authorsByPath, timeByPath };
+}
+
+// Full authorship context for `root`, collected ONCE per run.
+function collectAuthorship(root) {
+  if (!isGitRepo(root)) {
+    return {
+      available: false,
+      repository: null,
+      commitRange: null,
+      authorsForPath: () => [],
+      mostRecentCommitTime: () => null,
+    };
+  }
+
+  const prefix = getRootPrefix(root);
+  const { authorsByPath, timeByPath } = buildPathIndex(root);
+
+  return {
+    available: true,
+    repository: getRepository(root),
+    commitRange: getCommitRange(root),
+    authorsForPath(relPathFromRoot) {
+      if (typeof relPathFromRoot !== 'string' || !relPathFromRoot) return [];
+      const repoRel = prefix ? `${prefix}/${relPathFromRoot}` : relPathFromRoot;
+      const set = authorsByPath.get(repoRel);
+      return set ? [...set] : [];
+    },
+    // UNIX seconds of the most recent commit touching `relPathFromRoot`, or `null` when the path is untracked / history is unreadable.
+    mostRecentCommitTime(relPathFromRoot) {
+      if (typeof relPathFromRoot !== 'string' || !relPathFromRoot) return null;
+      const repoRel = prefix ? `${prefix}/${relPathFromRoot}` : relPathFromRoot;
+      const t = timeByPath.get(repoRel);
+      return t === undefined ? null : t;
+    },
+  };
+}
+
+// Builds an "is this author attributable?" predicate for one certifying identity.
+function buildAttributionPredicate(verifiedEmail, authorizedSet) {
+  const target = String(verifiedEmail || '').trim().toLowerCase();
+  const domainSuffix =
+    authorizedSet && authorizedSet.domain
+      ? `@${String(authorizedSet.domain).trim().toLowerCase()}`
+      : null;
+  const extra = new Set(
+    authorizedSet && Array.isArray(authorizedSet.extraEmails)
+      ? authorizedSet.extraEmails.map((e) => String(e).trim().toLowerCase())
+      : [],
+  );
+  return (author) => {
+    const a = String(author || '').toLowerCase();
+    if (target && a === target) return true;
+    if (domainSuffix && a.endsWith(domainSuffix)) return true;
+    if (extra.has(a)) return true;
+    return false;
+  };
+}
+
+// Applies the ADR-017 gate (with the ADR-023 widening for test identities) to ONE sampled Skill.
+function attributeSample(sample, verifiedEmail, authorship, authorizedSet = null) {
+  const isAttributable = buildAttributionPredicate(verifiedEmail, authorizedSet);
+  const files = Array.isArray(sample.files) ? sample.files : [];
+
+  const consideredEmails = new Set();
+  const attributableFiles = [];
+  const fileAttribution = [];
+
+  for (const file of files) {
+    const authors = authorship.authorsForPath(file.path);
+    for (const a of authors) consideredEmails.add(a);
+    const attributed = authors.some((a) => isAttributable(a));
+    if (attributed) attributableFiles.push(file);
+    fileAttribution.push({ path: file.path, authors, attributed });
+  }
+
+  const authorEmails = [...consideredEmails].map((email) => ({
+    email,
+    matched: isAttributable(email),
+  }));
+
+  return {
+    attributableFiles,
+    authorEmails,
+    fileAttribution,
+    certifiable: attributableFiles.length > 0,
+  };
+}
+
+module.exports = {
+  collectAuthorship,
+  AUTHORSHIP_LOG_ARGS,
+  attributeSample,
+  // exported for unit tests
+  normalizeRemote,
+  isGitRepo,
+};

package/src/automations-detector.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { getHomeDir } = require('./env-paths');
+
+// Deterministic (no-LLM) automations detector (talents-ai-score, issue 017 / ADR-013-014).
+
+const AI_CLI_NAMES = ['claude', 'aider', 'gemini', 'codex'];
+const AI_CLI_RE = new RegExp(`\\b(${AI_CLI_NAMES.join('|')})\\b`, 'i');
+
+function mentionsAiCli(text) {
+  return typeof text === 'string' && AI_CLI_RE.test(text);
+}
+
+function looksLikeJsonPiping(text) {
+  if (typeof text !== 'string') return false;
+  return mentionsAiCli(text) && /\|/.test(text) && /(--json\b|(^|\s)-p\b)/.test(text);
+}
+
+const MAX_SHELL_SCRIPT_BYTES = 200_000; // safety cap, never a product requirement
+const MAX_SHELL_SCRIPTS = 50;
+
+/* ---------- 1 & 2: scripts (npm + shell) ---------- */
+
+function scanNpmScripts(root) {
+  let raw;
+  try {
+    raw = fs.readFileSync(path.join(root, 'package.json'), 'utf8');
+  } catch {
+    return { aiMentions: 0, jsonPiping: 0 };
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return { aiMentions: 0, jsonPiping: 0 };
+  }
+  const scripts = pkg && typeof pkg.scripts === 'object' ? pkg.scripts : {};
+  let aiMentions = 0;
+  let jsonPiping = 0;
+  for (const command of Object.values(scripts)) {
+    if (mentionsAiCli(command)) aiMentions += 1;
+    if (looksLikeJsonPiping(command)) jsonPiping += 1;
+  }
+  return { aiMentions, jsonPiping };
+}
+
+function scanShellScripts(root) {
+  const dir = path.join(root, 'scripts');
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return { aiMentions: 0, jsonPiping: 0 };
+  }
+  let aiMentions = 0;
+  let jsonPiping = 0;
+  let scanned = 0;
+  for (const entry of entries) {
+    if (scanned >= MAX_SHELL_SCRIPTS) break;
+    if (!entry.isFile() || !entry.name.endsWith('.sh')) continue;
+    scanned += 1;
+    const file = path.join(dir, entry.name);
+    let content;
+    try {
+      const st = fs.statSync(file);
+      if (st.size > MAX_SHELL_SCRIPT_BYTES) continue;
+      content = fs.readFileSync(file, 'utf8');
+    } catch {
+      continue;
+    }
+    if (mentionsAiCli(content)) aiMentions += 1;
+    if (looksLikeJsonPiping(content)) jsonPiping += 1;
+  }
+  return { aiMentions, jsonPiping };
+}
+
+/* ---------- 3: schedulers (inspected-where-possible) ---------- */
+
+// cron: the CURRENT user's own crontab only (`crontab -l`), never the system-wide crontab (would need elevated permissions, not attempted).
+function probeCron() {
+  let out;
+  try {
+    out = execFileSync('crontab', ['-l'], { timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'] }).toString('utf8');
+  } catch {
+    return { inspected: false, matches: 0 }; // no crontab / binary missing / not permitted: not invented
+  }
+  const lines = out.split('\n').filter((l) => l.trim() && !l.trim().startsWith('#'));
+  return { inspected: true, matches: lines.filter(mentionsAiCli).length };
+}
+
+// launchd (macOS): the user's own ~/Library/LaunchAgents only (never LaunchDaemons, system-wide, needs root).
+function probeLaunchd(home) {
+  const dir = path.join(home, 'Library', 'LaunchAgents');
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return { inspected: false, matches: 0 };
+  }
+  let matches = 0;
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.plist')) continue;
+    try {
+      const content = fs.readFileSync(path.join(dir, entry.name), 'utf8');
+      if (mentionsAiCli(content)) matches += 1;
+    } catch {
+      /* unreadable: skip, never invented */
+    }
+  }
+  return { inspected: true, matches };
+}
+
+// pm2: the user's own process dump (~/.pm2/dump.pm2, JSON). Counts AI-CLI
+// mentions across the whole dump — coarse but derived, never returns it.
+function probePm2(home) {
+  let raw;
+  try {
+    raw = fs.readFileSync(path.join(home, '.pm2', 'dump.pm2'), 'utf8');
+  } catch {
+    return { inspected: false, matches: 0 };
+  }
+  const matches = (raw.match(new RegExp(AI_CLI_RE.source, 'gi')) || []).length;
+  return { inspected: true, matches };
+}
+
+// systemd (Linux, user-level only): ~/.config/systemd/user/*.service.
+// Never the system-wide /etc/systemd (needs root, not attempted).
+function probeSystemdUser(home) {
+  const dir = path.join(home, '.config', 'systemd', 'user');
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return { inspected: false, matches: 0 };
+  }
+  let matches = 0;
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.service')) continue;
+    try {
+      const content = fs.readFileSync(path.join(dir, entry.name), 'utf8');
+      if (mentionsAiCli(content)) matches += 1;
+    } catch {
+      /* unreadable: skip, never invented */
+    }
+  }
+  return { inspected: true, matches };
+}
+
+// Deterministic (no-LLM) automations detection.
+function detectAutomations(root) {
+  const home = getHomeDir();
+  const npm = scanNpmScripts(root);
+  const shell = scanShellScripts(root);
+
+  return {
+    scripts: { npm: npm.aiMentions, shell: shell.aiMentions },
+    jsonPiping: npm.jsonPiping + shell.jsonPiping,
+    schedulers: {
+      cron: probeCron(),
+      launchd: probeLaunchd(home),
+      pm2: probePm2(home),
+      systemd: probeSystemdUser(home),
+    },
+  };
+}
+
+module.exports = { detectAutomations, mentionsAiCli, looksLikeJsonPiping };

package/src/availability-client.js

@@ -0,0 +1,93 @@
+'use strict';
+
+// Availability client. VIEW = GET `works/me/availability`; SET = PUT
+// (the same endpoint register uses).
+
+const { postJsonWithTimeout } = require('./backend-request');
+const { reasonForError } = require('./onboarding-client');
+const { WORK_MODES } = require('./onboarding-flow');
+
+const DEFAULT_TIMEOUT_MS = 20000;
+
+function parseJson(raw) {
+  try {
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+
+function bearerHeaders(accessToken) {
+  const headers = {};
+  if (typeof accessToken === 'string' && accessToken) headers.Authorization = `Bearer ${accessToken}`;
+  return headers;
+}
+
+function bool(v) {
+  return v === true ? true : v === false ? false : null;
+}
+
+function str(v) {
+  return typeof v === 'string' && v ? v : null;
+}
+
+function normalizeAvailability(data) {
+  const it = data && typeof data === 'object' ? data : {};
+  return {
+    available: bool(it.available),
+    // A numeric hours value (incl. 0) must survive, not be dropped as "absent".
+    monthlyHours: typeof it.monthlyHours === 'number' ? String(it.monthlyHours) : str(it.monthlyHours),
+    workModes: Array.isArray(it.workModes) ? it.workModes.filter((m) => WORK_MODES.includes(m)) : [],
+    country: str(it.country),
+    subdivision: str(it.subdivision),
+    timezone: str(it.timezone),
+    city: typeof it.city === 'number' ? it.city : null,
+    longFullTimeProjects: bool(it.longFullTimeProjects),
+    availabilityExpiringDate: it.availabilityExpiringDate ? String(it.availabilityExpiringDate) : null,
+  };
+}
+
+async function requestAvailability({ hubAccessToken } = {}, { endpoint, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  if (!hubAccessToken) return { ok: false, reason: 'no-hub-token' };
+  let res;
+  try {
+    res = await postJsonWithTimeout(endpoint, null, timeoutMs, 'GET', null, bearerHeaders(hubAccessToken));
+  } catch (e) {
+    return { ok: false, reason: (e && e.kind) || 'network-error' };
+  }
+  if (res.status === 404) return { ok: false, reason: 'not-found' };
+  if (res.status < 200 || res.status >= 300) return { ok: false, reason: reasonForError(res.status, res.raw) };
+  const env = parseJson(res.raw);
+  const data = env && env.status === 'OK' ? env.data : env;
+  if (!data || typeof data !== 'object') return { ok: false, reason: 'bad-response' };
+  return { ok: true, availability: normalizeAvailability(data) };
+}
+
+async function fetchAvailability(deps = {}, { hubAccessToken, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  const {
+    getMeAvailabilityEndpoint = require('./config').getMeAvailabilityEndpoint,
+    requestAvailability: request = requestAvailability,
+  } = deps;
+  const endpoint = getMeAvailabilityEndpoint();
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  return request({ hubAccessToken }, { endpoint, timeoutMs });
+}
+
+// Partial upsert: only the changed fields ride the PUT (all fields optional).
+async function saveAvailability(deps = {}, { hubAccessToken, availability, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  const {
+    getSetAvailabilityEndpoint = require('./config').getSetAvailabilityEndpoint,
+    requestSetAvailability = require('./onboarding-client').requestSetAvailability,
+  } = deps;
+  const endpoint = getSetAvailabilityEndpoint();
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  return requestSetAvailability({ availability, hubAccessToken }, { endpoint, timeoutMs });
+}
+
+module.exports = {
+  normalizeAvailability,
+  requestAvailability,
+  fetchAvailability,
+  saveAvailability,
+};

package/src/availability-flow.js

@@ -0,0 +1,124 @@
+'use strict';
+
+// `availability` flow: view (hours/month, open-to-work, location), and `--set`
+// (interactive, explicit confirmation — it writes your profile). Talent Bearer.
+
+const { styleLabelPrefix } = require('./ansi');
+const { WORK_MODES, validateAvailability } = require('./onboarding-flow');
+
+function makeAvailabilityDeps(overrides = {}) {
+  const client = require('./availability-client');
+  return {
+    fetchAvailability: (opts) => client.fetchAvailability({}, opts),
+    saveAvailability: (opts) => client.saveAvailability({}, opts),
+    promptSelect: (opts) => require('./prompt-select').promptSelect(opts),
+    promptMultiSelect: (opts) => require('./prompt-select').promptMultiSelect(opts),
+    ...overrides,
+  };
+}
+
+function workModesLine(fp, modes) {
+  return modes && modes.length ? modes.map((m) => fp.workModeLabels[m] || m).join(', ') : fp.unknown;
+}
+
+function locationLine(a) {
+  return [a.country, a.subdivision, a.timezone].filter(Boolean).join(' · ') || null;
+}
+
+function renderView(io, fp, a) {
+  io.section(fp.title);
+  io.notify(styleLabelPrefix(fp.openToWork(a.available === true ? fp.yes : a.available === false ? fp.no : fp.unknown)));
+  io.notify(styleLabelPrefix(fp.monthlyHours(a.monthlyHours != null ? a.monthlyHours : fp.unknown)));
+  io.notify(styleLabelPrefix(fp.workModes(workModesLine(fp, a.workModes))));
+  const loc = locationLine(a);
+  if (loc) io.notify(styleLabelPrefix(fp.location(loc)));
+  if (a.availabilityExpiringDate) io.notify(styleLabelPrefix(fp.expires(a.availabilityExpiringDate)));
+  io.success(fp.done);
+}
+
+async function runSet({ io, ask, session, catalog, opts, deps }) {
+  const fp = catalog.availability;
+  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 yesNo = [{ label: fp.yes, value: true }, { label: fp.no, value: false }];
+  const pickYesNo = (header) => deps.promptSelect({ ask, stdinIsTTY: opts.stdinIsTTY, out: selOut, header, items: yesNo, labelFor: (x) => x.label, input: opts.input, output: opts.output });
+
+  const read = await io.withProgress(fp.loading, () => deps.fetchAvailability({ hubAccessToken }));
+  const current = read.ok ? read.availability : null;
+  if (!read.ok && read.reason !== 'not-found') {
+    io.error(fp.fetchFailed(read.reason));
+    return { ok: false, reason: read.reason };
+  }
+
+  io.section(fp.setTitle);
+  if (current) renderView({ section: () => {}, notify: io.notify, success: () => {} }, fp, current);
+
+  // Arrow-key yes/no pickers for the discrete fields.
+  const openPick = await pickYesNo(fp.askOpenToWork);
+  if (!openPick) { io.notify(fp.setCancelled); return { ok: true, cancelled: true }; }
+  const available = openPick.value;
+  const hoursRaw = (await io.ask(fp.askMonthlyHours)).trim();
+  if (hoursRaw && !/^\d{1,3}$/.test(hoursRaw)) { io.error(fp.monthlyHoursInvalid); return { ok: false, reason: 'bad-hours' }; }
+  const pickedModes = await deps.promptMultiSelect({
+    ask,
+    stdinIsTTY: opts.stdinIsTTY,
+    out: selOut,
+    items: WORK_MODES,
+    labelFor: (v) => fp.workModeLabels[v] || v,
+    header: fp.workModesAsk,
+    hint: fp.workModesHint,
+    initialMarked: (current && Array.isArray(current.workModes)) ? current.workModes.map((m) => WORK_MODES.indexOf(m)).filter((i) => i >= 0) : [],
+    input: opts.input,
+    output: opts.output,
+  });
+  // Reuse the register validation (dedupe/upcase, enum check) — no duplicated logic.
+  const workModes = validateAvailability({ workModes: pickedModes }).availability.workModes || [];
+  if (workModes.length === 1 && workModes[0] === 'REMOTE') io.notify(fp.onlyRemoteNote);
+
+  // Only the asked fields ride the partial upsert.
+  const body = { available };
+  if (hoursRaw) body.monthlyHours = hoursRaw;
+  if (workModes.length) body.workModes = workModes;
+
+  io.notify(fp.setDiff(
+    `${available ? fp.yes : fp.no}`,
+    hoursRaw || (current && current.monthlyHours) || fp.unknown,
+    workModesLine(fp, workModes),
+  ));
+  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.saveAvailability({ hubAccessToken, availability: body }));
+  if (!res.ok) { io.error(fp.setFailed(res.reason)); return { ok: false, reason: res.reason }; }
+  io.success(fp.setDone);
+  return { ok: true, set: body };
+}
+
+async function runAvailability({ io, rawOut, ask, session, catalog, opts = {}, deps = makeAvailabilityDeps() }) {
+  const fp = catalog.availability;
+  if (opts.set) return runSet({ io, ask, session, catalog, opts, deps });
+
+  const hubAccessToken = session ? session.hubAccessToken : null;
+  const doFetch = () => deps.fetchAvailability({ hubAccessToken });
+  const res = opts.json ? await doFetch() : await io.withProgress(fp.loading, doFetch);
+  if (!res.ok) {
+    io.error(res.reason === 'not-found' ? fp.notFound : fp.fetchFailed(res.reason));
+    return { ok: false, reason: res.reason };
+  }
+  if (opts.json) {
+    (rawOut || ((s) => process.stdout.write(s)))(`${JSON.stringify({ ok: true, availability: res.availability }, null, 2)}\n`);
+    return { ok: true, availability: res.availability };
+  }
+  renderView(io, fp, res.availability);
+  return { ok: true, availability: res.availability };
+}
+
+module.exports = {
+  makeAvailabilityDeps,
+  runAvailability,
+  locationLine,
+};