shakers-cli-beta 0.8.0-beta.0

package/src/scope-signals.js

@@ -0,0 +1,148 @@
+'use strict';
+
+const { collectGitActivity } = require('./git-activity');
+const { collectWorkStreams } = require('./work-streams');
+const { collectDetectionEvidence } = require('./detection-evidence');
+
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+
+function maxOrNull(a, b) {
+  if (a === null || a === undefined) return b ?? null;
+  if (b === null || b === undefined) return a;
+  return Math.max(a, b);
+}
+
+function minOrNull(a, b) {
+  if (a === null || a === undefined) return b ?? null;
+  if (b === null || b === undefined) return a;
+  return Math.min(a, b);
+}
+
+function mergeGitActivity(list) {
+  const present = list.filter(Boolean);
+  if (present.length === 0) return null;
+  const filesByType = {};
+  let commitCount = 0;
+  let authoredCommitCount = 0;
+  let linesAdded = 0;
+  let linesDeleted = 0;
+  let spanDays = 0;
+  for (const g of present) {
+    commitCount += g.commitCount;
+    authoredCommitCount += g.authoredCommitCount;
+    linesAdded += g.linesAdded;
+    linesDeleted += g.linesDeleted;
+    spanDays = Math.max(spanDays, g.spanDays);
+    for (const [ext, c] of Object.entries(g.filesByType || {})) {
+      filesByType[ext] = (filesByType[ext] || 0) + c;
+    }
+  }
+  return {
+    commitCount,
+    authoredCommitCount,
+    linesAdded,
+    linesDeleted,
+    filesByType,
+    velocity: round2(commitCount / Math.max(spanDays, 1)),
+    spanDays,
+  };
+}
+
+function mergeWorkStreams(list) {
+  const present = list.filter(Boolean);
+  if (present.length === 0) return null;
+  let streamCount = 0;
+  let multiDayStreams = 0;
+  let maxStreamSpanDays = 0;
+  let sumAvg = 0;
+  for (const w of present) {
+    streamCount += w.streamCount;
+    multiDayStreams += w.multiDayStreams;
+    maxStreamSpanDays = Math.max(maxStreamSpanDays, w.maxStreamSpanDays);
+    sumAvg += w.avgCommitsPerSession;
+  }
+  return {
+    streamCount,
+    multiDayStreams,
+    avgCommitsPerSession: round2(sumAvg / present.length),
+    maxStreamSpanDays,
+  };
+}
+
+function mergeCandidate(existing, incoming) {
+  existing.authoredFileCount += incoming.authoredFileCount;
+  existing.totalFileCount += incoming.totalFileCount;
+  existing.authorshipKnown = existing.authorshipKnown || incoming.authorshipKnown;
+  existing.depth = maxOrNull(existing.depth, incoming.depth);
+  existing.recencyDays = minOrNull(existing.recencyDays, incoming.recencyDays);
+  existing.vendored = existing.vendored && incoming.vendored;
+}
+
+function agentKey(a) {
+  return `${a.name}|${(a.tools || []).join(',')}|${a.model || ''}`;
+}
+
+function mergeProvenance(a, b) {
+  if (!b) return a;
+  if (!a) return { ...b };
+  return {
+    fork: a.fork || b.fork,
+    forkSignal: a.forkSignal || b.forkSignal || null,
+    boilerplate: a.boilerplate || b.boilerplate,
+    boilerplateMarker: a.boilerplateMarker || b.boilerplateMarker || null,
+  };
+}
+
+function mergeDetectionEvidence(list) {
+  const present = list.filter(Boolean);
+  if (present.length === 0) return null;
+  const skillsByTech = new Map();
+  const agentsByKey = new Map();
+  let provenance = null;
+  for (const de of present) {
+    for (const s of de.skills || []) {
+      const existing = skillsByTech.get(s.tech);
+      if (!existing) skillsByTech.set(s.tech, { ...s });
+      else mergeCandidate(existing, s);
+    }
+    for (const a of de.agents || []) {
+      const k = agentKey(a);
+      const existing = agentsByKey.get(k);
+      if (!existing) agentsByKey.set(k, { ...a });
+      else mergeCandidate(existing, a);
+    }
+    provenance = mergeProvenance(provenance, de.provenance);
+  }
+  return {
+    skills: [...skillsByTech.values()],
+    agents: [...agentsByKey.values()],
+    provenance,
+  };
+}
+
+function collectScopedGitActivity(toplevels, verifiedEmail) {
+  return mergeGitActivity(
+    toplevels.map((root) => collectGitActivity(root, verifiedEmail)),
+  );
+}
+
+function collectScopedWorkStreams(toplevels) {
+  return mergeWorkStreams(toplevels.map((root) => collectWorkStreams(root)));
+}
+
+function collectScopedDetectionEvidence(toplevels, verifiedEmail, report) {
+  return mergeDetectionEvidence(
+    toplevels.map((root) => collectDetectionEvidence(root, verifiedEmail, report)),
+  );
+}
+
+module.exports = {
+  mergeGitActivity,
+  mergeWorkStreams,
+  mergeDetectionEvidence,
+  collectScopedGitActivity,
+  collectScopedWorkStreams,
+  collectScopedDetectionEvidence,
+};

package/src/secret-prompt.js

@@ -0,0 +1,72 @@
+'use strict';
+
+// SECRET PROMPT — reads a secret WITHOUT painting it (issue 102).
+
+const CTRL_C = '\u0003';
+const CTRL_D = '\u0004';
+const BACKSPACE = /[\u0008\u007f]/;
+
+// Reads a secret from a RAW tty.
+function readSecretRaw({ input, output, mask = '' } = {}) {
+  return new Promise((resolve, reject) => {
+    let value = '';
+    let done = false;
+
+    const restore = () => {
+      if (done) return;
+      done = true;
+      // Order matters: stop listening BEFORE leaving raw mode, so a keystroke that
+      // arrives during teardown is not delivered to a half-restored terminal.
+      try { input.removeListener('data', onData); } catch { /* already gone */ }
+      if (input.setRawMode) { try { input.setRawMode(false); } catch { /* not a TTY any more */ } }
+    };
+
+    function onData(chunk) {
+      const s = String(chunk);
+      for (const ch of s) {
+        if (ch === '\r' || ch === '\n') {
+          restore();
+          output.write('\n');
+          resolve(value);
+          return;
+        }
+        if (ch === CTRL_C || ch === CTRL_D) {
+          // Restore FIRST, then report the cancellation: whatever the caller does
+          // with it (exit, retry), the terminal is already usable.
+          restore();
+          output.write('\n');
+          resolve(null);
+          return;
+        }
+        if (BACKSPACE.test(ch)) {
+          if (value.length) {
+            value = value.slice(0, -1);
+            // Only erase on screen if something was drawn there.
+            if (mask) output.write('\b \b');
+          }
+          continue;
+        }
+        // Ignore the rest of the C0 controls (arrows arrive as escape sequences and
+        // would otherwise land inside the secret).
+        if (ch < ' ') continue;
+        value += ch;
+        if (mask) output.write(mask);
+      }
+    }
+
+    try {
+      if (input.setRawMode) input.setRawMode(true);
+      if (input.resume) input.resume();
+      input.on('data', onData);
+    } catch (err) {
+      restore();
+      reject(err);
+    }
+  });
+}
+
+function canPromptSecretly(input) {
+  return !!(input && input.isTTY && typeof input.setRawMode === 'function');
+}
+
+module.exports = { readSecretRaw, canPromptSecretly };

package/src/session-gate.js

@@ -0,0 +1,30 @@
+'use strict';
+
+// Whether a non-exempt command may run: an active session, or a durable cookie
+// that can mint a fresh hub JWT right now. Reject only when neither holds.
+
+const { loadAuthSession, sessionStatus } = require('./auth-session-store');
+const { ensureFreshSession } = require('./session-refresh');
+
+function jwtUsable(session, now) {
+  const exp = Date.parse(String((session && session.accessTokenExpiresAt) || ''));
+  return Number.isFinite(exp) && exp > now;
+}
+
+async function hasUsableSession(env = process.env, deps = {}) {
+  const {
+    loadAuthSession: load = loadAuthSession,
+    ensureFreshSession: refresh = ensureFreshSession,
+    now = Date.now(),
+  } = deps;
+
+  const session = load(env);
+  if (sessionStatus(session, now) === 'active') return true;
+  if (!session || !session.cookie) return false;
+
+  let refreshed = null;
+  try { refreshed = await refresh(env, { now }); } catch { refreshed = null; }
+  return jwtUsable(refreshed || load(env), now);
+}
+
+module.exports = { hasUsableSession, jwtUsable };

package/src/session-refresh.js

@@ -0,0 +1,51 @@
+'use strict';
+
+// On-demand hub-JWT minting for an email (better-auth) session.
+
+const REFRESH_MARGIN_MS = 120 * 1000;
+
+function jwtStillFresh(accessTokenExpiresAt, now, marginMs) {
+  const exp = Date.parse(String(accessTokenExpiresAt || ''));
+  if (!Number.isFinite(exp)) return false;
+  return exp - now > marginMs;
+}
+
+async function ensureFreshSession(env = process.env, deps = {}) {
+  const {
+    loadAuthSession = require('./auth-session-store').loadAuthSession,
+    saveAuthSession = require('./auth-session-store').saveAuthSession,
+    getAuthTokenEndpoint = require('./config').getAuthTokenEndpoint,
+    requestAuthToken = require('./auth-client').requestAuthToken,
+    now = Date.now(),
+    marginMs = REFRESH_MARGIN_MS,
+  } = deps;
+
+  const session = loadAuthSession(env);
+  if (!session) return null;
+  if (!session.cookie) return session;
+  if (session.accessToken && jwtStillFresh(session.accessTokenExpiresAt, now, marginMs)) return session;
+
+  const endpoint = getAuthTokenEndpoint(env);
+  if (!endpoint) return session;
+
+  const tok = await requestAuthToken({ cookie: session.cookie }, { endpoint });
+  if (!tok.ok) return session;
+
+  try {
+    saveAuthSession(
+      {
+        ...session,
+        accessToken: tok.accessToken,
+        hubAccessToken: tok.accessToken,
+        accessTokenExpiresAt: tok.expiresAt,
+        cookieExpiresAt: session.expiresAt,
+      },
+      env,
+    );
+  } catch {
+    return session;
+  }
+  return loadAuthSession(env);
+}
+
+module.exports = { ensureFreshSession, jwtStillFresh, REFRESH_MARGIN_MS };

package/src/session-scan.js

@@ -0,0 +1,336 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getHomeDir } = require('./env-paths');
+const { scrubSecrets } = require('./agent-synthesis');
+
+// GLOBAL, machine-wide inventory of AI coding-tool SESSIONS (hybrid evaluation, Slice 1).
+
+const MAX_FILES_PER_TOOL = 2000;
+const MAX_BYTES_PER_FILE = 8 * 1024 * 1024;
+const MAX_COMMAND_SAMPLE = 20;
+const MAX_COMMAND_LEN = 200;
+const IDLE_GAP_CAP_MS = 25 * 60 * 1000;
+// Recency window for sessions90d / activeDaysPerWeek only; all-time metrics untouched.
+const TRACTION_WINDOW_DAYS = 90;
+const TRACTION_WINDOW_MS = TRACTION_WINDOW_DAYS * 24 * 60 * 60 * 1000;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+function activeMsForObjects(objects) {
+  const stamps = [];
+  for (const o of objects) {
+    if (o && typeof o.timestamp === 'string') {
+      const t = Date.parse(o.timestamp);
+      if (Number.isFinite(t)) stamps.push(t);
+    }
+  }
+  stamps.sort((a, b) => a - b);
+  let ms = 0;
+  for (let i = 1; i < stamps.length; i++) {
+    ms += Math.min(stamps[i] - stamps[i - 1], IDLE_GAP_CAP_MS);
+  }
+  return ms;
+}
+
+// Most-recent parseable timestamp = when the session was last active; null if none.
+function latestTimestampOf(objects) {
+  let latest = null;
+  for (const o of objects) {
+    if (o && typeof o.timestamp === 'string') {
+      const t = Date.parse(o.timestamp);
+      if (Number.isFinite(t) && (latest === null || t > latest)) latest = t;
+    }
+  }
+  return latest;
+}
+
+// distinct active days ÷ weeks of the observed active span (clamped ≥1 week), capped at 7.
+function activeDaysPerWeekFrom(activeDayStrings) {
+  const dayEpochs = [...activeDayStrings].map((d) => Date.parse(`${d}T00:00:00Z`));
+  if (dayEpochs.length === 0) return 0;
+  const spanDays =
+    Math.floor((Math.max(...dayEpochs) - Math.min(...dayEpochs)) / DAY_MS) + 1;
+  const weeks = Math.max(1, spanDays / 7);
+  return Math.min(7, Math.round((dayEpochs.length / weeks) * 10) / 10);
+}
+
+function isTranscriptFile(name) {
+  if (name.endsWith('.meta.json')) return false;
+  if (name === 'sessions-index.json') return false;
+  return name.endsWith('.jsonl') || name.endsWith('.json');
+}
+
+function isSubagentFile(filePath) {
+  return filePath.split(path.sep).includes('subagents');
+}
+const FILE_TOOL_NAMES = new Set([
+  'Read',
+  'Edit',
+  'MultiEdit',
+  'Write',
+  'NotebookEdit',
+]);
+const PLANNING_TOOL_NAMES = new Set(['ExitPlanMode', 'TodoWrite']);
+
+function toolSources(env = process.env) {
+  const home = getHomeDir(env);
+  return [
+    { tool: 'claude', dir: path.join(home, '.claude', 'projects') },
+    { tool: 'codex', dir: path.join(home, '.codex', 'sessions') },
+    { tool: 'cursor', dir: path.join(home, '.cursor', 'chats') },
+  ];
+}
+
+function listSessionFiles(root) {
+  const out = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else if (entry.isFile() && isTranscriptFile(entry.name)) {
+        out.push(full);
+        if (out.length >= MAX_FILES_PER_TOOL) return out;
+      }
+    }
+  }
+  return out;
+}
+
+function pushCommand(acc, command) {
+  if (typeof command !== 'string') return;
+  acc.bashCommandsCount += 1;
+  if (acc.commandSample.length >= MAX_COMMAND_SAMPLE) return;
+  const scrubbed = scrubSecrets(command).trim().slice(0, MAX_COMMAND_LEN);
+  if (scrubbed && !acc.commandSample.includes(scrubbed)) {
+    acc.commandSample.push(scrubbed);
+  }
+}
+
+function harvestToolUse(node, acc) {
+  if (!node || typeof node !== 'object') return;
+  const name = node.name;
+  const input = node.input && typeof node.input === 'object' ? node.input : null;
+  if (name === 'Bash' && input) {
+    pushCommand(acc, input.command);
+  } else if (name === 'Shell' && input) {
+    pushCommand(acc, input.command);
+  } else if (FILE_TOOL_NAMES.has(name) && input) {
+    const p = input.file_path || input.notebook_path;
+    if (typeof p === 'string' && p) acc.filesTouched.add(p);
+  } else if (PLANNING_TOOL_NAMES.has(name)) {
+    acc.planningSignalCount = (acc.planningSignalCount || 0) + 1;
+  }
+}
+
+function harvestObject(o, acc) {
+  const msg = o && o.message ? o.message : o;
+  const content = msg && Array.isArray(msg.content) ? msg.content : null;
+  if (content) {
+    for (const c of content) {
+      if (c && c.type === 'tool_use') harvestToolUse(c, acc);
+    }
+  }
+  if (o && typeof o.cwd === 'string' && o.cwd) acc.projectKeys.add(o.cwd);
+}
+
+function readSessionObjects(file) {
+  const out = [];
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+  } catch {
+    return out;
+  }
+  try {
+    const { size } = fs.fstatSync(fd);
+    const readLen = Math.min(size, MAX_BYTES_PER_FILE);
+    const buf = Buffer.allocUnsafe(readLen);
+    fs.readSync(fd, buf, 0, readLen, 0);
+    const lines = buf.toString('utf8').split('\n');
+    const complete = size > MAX_BYTES_PER_FILE ? lines.slice(0, -1) : lines;
+    for (const ln of complete) {
+      if (!ln) continue;
+      let o;
+      try {
+        o = JSON.parse(ln);
+      } catch {
+        continue;
+      }
+      out.push(o);
+    }
+  } catch {
+    /* unreadable mid-stream — return what parsed */
+  } finally {
+    try {
+      fs.closeSync(fd);
+    } catch {
+      /* already closed */
+    }
+  }
+  return out;
+}
+
+function scanFile(file, acc) {
+  for (const o of readSessionObjects(file)) harvestObject(o, acc);
+}
+
+function resolveFileCwd(objects) {
+  for (const o of objects) {
+    if (o && typeof o.cwd === 'string' && o.cwd) return o.cwd;
+  }
+  return null;
+}
+
+function fileInScope(cwd, selectedCwds) {
+  if (selectedCwds === null) return true;
+  return cwd !== null && selectedCwds.has(cwd);
+}
+
+// Yields every parsed session object across every known AI-tool session directory on this machine, tagged with the tool it came from.
+function* iterateSessionObjects(env = process.env) {
+  for (const source of toolSources(env)) {
+    const files = listSessionFiles(source.dir);
+    for (const file of files) {
+      const objects = readSessionObjects(file);
+      const cwd = resolveFileCwd(objects);
+      for (const obj of objects) {
+        yield { tool: source.tool, obj, cwd, filePath: file };
+      }
+    }
+  }
+}
+
+// Scan every known AI-tool session directory on this machine.
+function makeSessionsAccumulator() {
+  const toolsSeen = [];
+  let sessionCount = 0;
+  let subagentRunCount = 0;
+  let activeMs = 0;
+  const filesTouched = new Set();
+  let bashCommandsCount = 0;
+  let planningSignalCount = 0;
+  const commandSample = [];
+  const projectKeysByTool = new Map();
+  // Recency-windowed session signals, from the same objects already read.
+  const windowCutoff = Date.now() - TRACTION_WINDOW_MS;
+  let sessions90d = 0;
+  const activeDaysInWindow = new Set();
+  let cur = null;
+
+  return {
+    startTool(tool) {
+      const projectKeys = new Set();
+      cur = {
+        tool,
+        projectKeys,
+        rootSessions: 0,
+        subagentRuns: 0,
+        acc: {
+          filesTouched,
+          commandSample,
+          projectKeys,
+          bashCommandsCount: 0,
+          planningSignalCount: 0,
+        },
+      };
+    },
+    addFile(file, objects) {
+      for (const o of objects) harvestObject(o, cur.acc);
+      if (isSubagentFile(file)) {
+        cur.subagentRuns += 1;
+      } else {
+        cur.rootSessions += 1;
+        activeMs += activeMsForObjects(objects);
+        // Root session in the 90d window → count it + record its (UTC) active day.
+        const lastTs = latestTimestampOf(objects);
+        if (lastTs !== null && lastTs >= windowCutoff) {
+          sessions90d += 1;
+          activeDaysInWindow.add(new Date(lastTs).toISOString().slice(0, 10));
+        }
+      }
+    },
+    endTool() {
+      if (cur.rootSessions === 0 && cur.subagentRuns === 0) {
+        cur = null;
+        return;
+      }
+      toolsSeen.push(cur.tool);
+      sessionCount += cur.rootSessions;
+      subagentRunCount += cur.subagentRuns;
+      bashCommandsCount += cur.acc.bashCommandsCount;
+      planningSignalCount += cur.acc.planningSignalCount;
+      projectKeysByTool.set(cur.tool, cur.projectKeys);
+      cur = null;
+    },
+    result() {
+      if (toolsSeen.length === 0) return null;
+      const keyToolCount = new Map();
+      for (const keys of projectKeysByTool.values()) {
+        for (const key of keys) {
+          keyToolCount.set(key, (keyToolCount.get(key) || 0) + 1);
+        }
+      }
+      let crossToolLinks = 0;
+      for (const count of keyToolCount.values()) {
+        if (count > 1) crossToolLinks += 1;
+      }
+      return {
+        toolsSeen,
+        sessionCount,
+        subagentRunCount,
+        activeHours: Math.round((activeMs / 3600000) * 10) / 10,
+        crossToolLinks,
+        filesTouchedCount: filesTouched.size,
+        bashCommandsCount,
+        planningSignalCount,
+        sessions90d,
+        activeDaysPerWeek: activeDaysPerWeekFrom(activeDaysInWindow),
+        redactedCommandSample: commandSample,
+      };
+    },
+  };
+}
+
+function walkSessionSignals(env = process.env, selectedCwds = null, onHumanObject = null) {
+  const sessions = makeSessionsAccumulator();
+  for (const source of toolSources(env)) {
+    const files = listSessionFiles(source.dir);
+    if (files.length === 0) continue;
+    sessions.startTool(source.tool);
+    for (const f of files) {
+      const objects = readSessionObjects(f);
+      if (!fileInScope(resolveFileCwd(objects), selectedCwds)) continue;
+      sessions.addFile(f, objects);
+      if (onHumanObject) {
+        for (const o of objects) onHumanObject(o);
+      }
+    }
+    sessions.endTool();
+  }
+  return sessions.result();
+}
+
+function collectSessions(env = process.env, selectedCwds = null) {
+  return walkSessionSignals(env, selectedCwds, null);
+}
+
+module.exports = {
+  collectSessions,
+  makeSessionsAccumulator,
+  walkSessionSignals,
+  toolSources,
+  listSessionFiles,
+  readSessionObjects,
+  resolveFileCwd,
+  iterateSessionObjects,
+};

package/src/session-signals.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { walkSessionSignals } = require('./session-scan');
+const { humanTextsFromObject } = require('./transcript-turns');
+const { makeSteeringAccumulator } = require('./steering-extract');
+const { makeDecisionsAccumulator } = require('./decisions-extract');
+const { makeBlindApprovalAccumulator } = require('./blind-approval-extract');
+const { makeSpecificityAccumulator } = require('./specificity-extract');
+
+function collectSessionSignals(env = process.env, selectedCwds = null) {
+  const steering = makeSteeringAccumulator();
+  const decisions = makeDecisionsAccumulator();
+  const blindApproval = makeBlindApprovalAccumulator();
+  const specificity = makeSpecificityAccumulator();
+  const sessions = walkSessionSignals(env, selectedCwds, (obj) => {
+    for (const text of humanTextsFromObject(obj)) {
+      steering.add(text);
+      decisions.add(text);
+      blindApproval.add(text);
+      specificity.add(text);
+    }
+  });
+  if (sessions) {
+    const approval = blindApproval.result();
+    const specific = specificity.result();
+    if (approval) Object.assign(sessions, approval);
+    if (specific) Object.assign(sessions, specific);
+  }
+  return {
+    sessions,
+    steering: steering.result(),
+    decisions: decisions.result(),
+  };
+}
+
+module.exports = { collectSessionSignals };