mover-os 4.7.7 → 4.7.9

package/src/dashboard/lib/feed-parser.js

@@ -0,0 +1,294 @@
+"use strict";
+
+// feed-parser.js — the live work feed. A plain sentence per real work event.
+//
+// SOURCE (live, local, never telemetry):
+//   1. ~/.claude/history.jsonl  — one line per real prompt the user typed into a
+//      Claude Code session: { display, timestamp(ms), project, sessionId }.
+//      Each line IS a real work event (a thing that actually happened in a real
+//      session under this vault). We tail the last N and turn each into a plain
+//      sentence.
+//   2. ~/.claude/sessions/*.json — live session descriptors:
+//      { pid, sessionId, cwd, startedAt(ms), updatedAt(ms), status, version,
+//        name, ... }. These tell us which sessions are open right now.
+//
+// SCOPING (Codex must-fix / v6 amendment fix 8 nice-to-have): resolve the
+// project slug AND each session cwd to a REALPATH and test containment against
+// THIS vault's realpath — NOT a loose `project` string match. A symlinked or
+// case-differing vault path still scopes correctly; an unrelated project that
+// happens to share a path prefix string does not leak in.
+//
+// HARD HONESTY (v6-PLAN-AMENDMENTS fix 8 + Fable Finding C — binding):
+//   - NO `cost` field. There is no per-step token source. We do not invent one.
+//   - NO `diff` field. There is no per-step diff source. The only file signal we
+//     emit is, at most, a real path that already appears in the user's own text.
+//   Each event is a plain sentence + ids. Nothing more.
+//
+// FALSE-ZERO (T261 discipline): if nothing real is happening under this vault —
+// no in-vault history events AND no in-vault sessions — return
+//   { available:false, events:[], activeSessions:[], caption:'' }.
+// We never fabricate scripted demo steps to fill an empty feed.
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { redactText } = require("./redaction");
+
+const HISTORY_FILE = path.join(os.homedir(), ".claude", "history.jsonl");
+const SESSIONS_DIR = path.join(os.homedir(), ".claude", "sessions");
+
+// A session counts as "active" only if its descriptor was touched recently.
+// Claude writes `updatedAt` on every turn; a stale file is a dead process whose
+// descriptor was never cleaned up. 30 min is generous for "this is live".
+const ACTIVE_WINDOW_MS = 30 * 60 * 1000;
+
+// ---------------------------------------------------------------------------
+// realpath-based vault scoping
+// ---------------------------------------------------------------------------
+
+// Resolve a path to its realpath when it exists on disk; fall back to a
+// lexical normalize (resolves `..`/`.` without touching disk) so a recorded
+// path for a since-deleted dir still scopes sanely. Never throws.
+function resolveReal(p) {
+  if (!p || typeof p !== "string") return null;
+  try {
+    return fs.realpathSync.native(p);
+  } catch (_) {
+    try {
+      return path.resolve(p);
+    } catch (_) {
+      return null;
+    }
+  }
+}
+
+// True when `child` is the same path as, or nested under, `root`. Compares on a
+// path-segment boundary (root + sep) so `/a/Mover OS` does NOT match
+// `/a/Mover OS Bundle 2`. Case-insensitive on darwin/win32 where the FS is.
+function isUnder(child, root) {
+  if (!child || !root) return false;
+  const ci = process.platform === "darwin" || process.platform === "win32";
+  let c = ci ? child.toLowerCase() : child;
+  let r = ci ? root.toLowerCase() : root;
+  if (c === r) return true;
+  const withSep = r.endsWith(path.sep) ? r : r + path.sep;
+  return c.startsWith(withSep);
+}
+
+// ---------------------------------------------------------------------------
+// event classification — plain, honest, source-backed
+// ---------------------------------------------------------------------------
+
+// A leading slash means the user invoked a workflow / command — a deliberate
+// "move". Everything else is a typed prompt to the agent terminal.
+function classify(display) {
+  const text = (display || "").trim();
+  if (text.startsWith("/")) {
+    // /plan-tomorrow, /log, /compact ... → kind is the bare command token.
+    const cmd = text.slice(1).split(/[\s\n]/, 1)[0].toLowerCase();
+    return { lane: "move", kind: cmd ? `/${cmd}` : "command" };
+  }
+  return { lane: "term", kind: "prompt" };
+}
+
+// Turn a raw multi-line prompt into one clean redacted sentence. We keep the
+// user's own words (that's the honest signal) — only collapse whitespace, trim
+// to a readable length, and run the privacy scrubber over the result.
+function toSentence(display) {
+  let t = (display || "").replace(/\s+/g, " ").trim();
+  if (!t) return "";
+  // Trim to a feed-readable length on a word boundary; mark truncation with an
+  // ellipsis so it never reads as a fabricated complete thought.
+  const MAX = 180;
+  if (t.length > MAX) {
+    const cut = t.slice(0, MAX);
+    const lastSpace = cut.lastIndexOf(" ");
+    t = (lastSpace > 80 ? cut.slice(0, lastSpace) : cut).trim() + "…";
+  }
+  return redactText(t).text;
+}
+
+// ---------------------------------------------------------------------------
+// session descriptors
+// ---------------------------------------------------------------------------
+
+function readSessions(vaultReal) {
+  let names;
+  try {
+    names = fs.readdirSync(SESSIONS_DIR);
+  } catch (_) {
+    return [];
+  }
+  const now = Date.now();
+  const sessions = [];
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    let desc;
+    try {
+      desc = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, name), "utf8"));
+    } catch (_) {
+      continue; // skip mid-write / corrupt descriptor
+    }
+    if (!desc || typeof desc !== "object") continue;
+    const cwdReal = resolveReal(desc.cwd);
+    const isThisVault = isUnder(cwdReal, vaultReal);
+    const updatedAt = Number(desc.updatedAt) || Number(desc.startedAt) || 0;
+    // status: trust the descriptor when present; otherwise infer from recency.
+    // A descriptor with no `status`/`updatedAt` that hasn't been touched in the
+    // active window is a leftover from a closed process — mark it "idle".
+    let status = typeof desc.status === "string" && desc.status ? desc.status : null;
+    const fresh = updatedAt > 0 && now - updatedAt <= ACTIVE_WINDOW_MS;
+    if (!status) status = fresh ? "active" : "idle";
+    sessions.push({
+      name: desc.name || "",
+      cwd: desc.cwd || "",
+      status,
+      version: desc.version || "",
+      startedAt: Number(desc.startedAt) ? new Date(Number(desc.startedAt)).toISOString() : null,
+      updatedAt: updatedAt ? new Date(updatedAt).toISOString() : null,
+      isThisVault: Boolean(isThisVault),
+      _fresh: fresh,
+    });
+  }
+  // Most-recently-active first.
+  sessions.sort((a, b) => (b.updatedAt || "").localeCompare(a.updatedAt || ""));
+  return sessions;
+}
+
+// Map a sessionId → a friendly name from the live descriptors, so a feed row
+// can show "landing-polar-overhaul" instead of a bare uuid.
+function buildSessionNameMap() {
+  const map = new Map();
+  let names;
+  try {
+    names = fs.readdirSync(SESSIONS_DIR);
+  } catch (_) {
+    return map;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    try {
+      const desc = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, name), "utf8"));
+      if (desc && desc.sessionId && desc.name) map.set(desc.sessionId, desc.name);
+    } catch (_) {
+      /* skip */
+    }
+  }
+  return map;
+}
+
+// ---------------------------------------------------------------------------
+// history events (tailed, scoped, redacted)
+// ---------------------------------------------------------------------------
+
+function readEvents(vaultReal, limit, sessionNames) {
+  let raw;
+  try {
+    raw = fs.readFileSync(HISTORY_FILE, "utf8");
+  } catch (_) {
+    return [];
+  }
+  const lines = raw.split("\n");
+  // Memoize realpath per distinct `project` string — history has thousands of
+  // lines but only a handful of distinct projects, and realpath hits disk.
+  const projectScopeCache = new Map();
+  const inVault = (project) => {
+    if (projectScopeCache.has(project)) return projectScopeCache.get(project);
+    const real = resolveReal(project);
+    const ok = isUnder(real, vaultReal);
+    projectScopeCache.set(project, ok);
+    return ok;
+  };
+
+  const events = [];
+  // Walk newest → oldest, collect up to `limit` in-vault events, then flip to
+  // chronological. Tailing from the end keeps this cheap on a large history.
+  for (let i = lines.length - 1; i >= 0 && events.length < limit; i--) {
+    const line = lines[i];
+    if (!line) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch (_) {
+      continue;
+    }
+    const project = obj.project;
+    if (!project || !inVault(project)) continue;
+
+    const display = obj.display;
+    const text = toSentence(display);
+    if (!text) continue; // nothing real to say
+
+    const tsMs = Number(obj.timestamp) || 0;
+    const { lane, kind } = classify(display);
+    const sessionId = obj.sessionId || "";
+    events.push({
+      ts: tsMs ? new Date(tsMs).toISOString() : null,
+      sessionId,
+      sessionName: (sessionId && sessionNames.get(sessionId)) || "",
+      lane, // 'move' | 'term'
+      kind,
+      text,
+      project,
+    });
+  }
+  events.reverse(); // chronological (oldest of the tail → newest)
+  return events;
+}
+
+// ---------------------------------------------------------------------------
+// public API
+// ---------------------------------------------------------------------------
+
+// compute({ vault, limit }) → live work-feed payload.
+//   available       false when nothing real is happening under this vault
+//   caption         one honest line summarizing the feed (or '')
+//   events          [{ ts, sessionId, sessionName, lane, kind, text, project }]
+//   activeSessions  [{ name, cwd, status, version, startedAt, updatedAt, isThisVault }]
+//
+// No `cost`, no `diff` — there is no per-step source for either (binding).
+function compute({ vault, limit = 40 } = {}) {
+  const EMPTY = { available: false, caption: "", events: [], activeSessions: [] };
+  if (!vault || typeof vault !== "string") return EMPTY;
+
+  const vaultReal = resolveReal(vault);
+  if (!vaultReal) return EMPTY;
+
+  const lim = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 40;
+
+  const sessions = readSessions(vaultReal);
+  const sessionNames = buildSessionNameMap();
+  const events = readEvents(vaultReal, lim, sessionNames);
+
+  // Active sessions surfaced to the UI = sessions running under THIS vault.
+  const activeSessions = sessions
+    .filter((s) => s.isThisVault)
+    .map(({ _fresh, ...s }) => s); // drop internal field
+
+  // False-zero discipline: a feed with no in-vault events AND no in-vault
+  // sessions is genuinely "nothing running" → unavailable, never a demo.
+  if (events.length === 0 && activeSessions.length === 0) return EMPTY;
+
+  // Honest caption from real counts only. "live" = a descriptor this vault owns
+  // that is currently active/busy (recently touched).
+  const liveNow = sessions.filter((s) => s.isThisVault && (s.status === "active" || s.status === "busy")).length;
+  let caption;
+  if (events.length === 0) {
+    caption = liveNow > 0 ? `${liveNow} session${liveNow === 1 ? "" : "s"} open — no events yet` : "";
+  } else {
+    const moves = events.filter((e) => e.lane === "move").length;
+    const parts = [`${events.length} recent event${events.length === 1 ? "" : "s"}`];
+    if (moves > 0) parts.push(`${moves} move${moves === 1 ? "" : "s"}`);
+    if (liveNow > 0) parts.push(`${liveNow} live`);
+    caption = parts.join(" · ");
+  }
+
+  return {
+    available: true,
+    caption,
+    events,
+    activeSessions,
+  };
+}
+
+module.exports = { compute };

package/src/dashboard/lib/forked-future.js

@@ -0,0 +1,60 @@
+"use strict";
+
+// forked-future.js — Two-path drift projection for the Briefing module.
+// Each scenario is a confidence-coned sparkline:
+//   path A: "if you hold the pattern" — extrapolates current drift trajectory
+//   path B: "if you break the pattern" — drift falls toward baseline (15-20)
+//
+// Pure function: takes current drift score + recent trajectory + active
+// patterns, returns two arrays of {value, lo, hi} points across N days.
+
+function compute({ driftScore = null, recent7d = [], activePatterns = [], horizonDays = 14 } = {}) {
+  if (!driftScore) return null;
+
+  const current = driftScore.value;
+  const baseline = 15;            // healthy floor target
+  const ceiling = 100;
+  const trendDelta = computeTrend(recent7d);
+  const patternWeight = Math.min(1, (activePatterns || []).filter(p => p.confidence >= 3).length * 0.15);
+
+  // Path A: hold the pattern. Trajectory continues at observed slope, with
+  // pattern weight pulling toward ceiling (active Conf 3+ patterns add drift).
+  const slopeA = trendDelta + 0.6 + patternWeight * 0.8;
+  const holdPath = [];
+  for (let i = 0; i <= horizonDays; i++) {
+    const v = Math.min(ceiling, Math.max(0, current + slopeA * i));
+    const spread = 3 + i * 0.8; // widening confidence cone
+    holdPath.push({ day: i, value: round(v), lo: round(v - spread), hi: round(Math.min(ceiling, v + spread)) });
+  }
+
+  // Path B: break the pattern. Drift decays toward baseline at -2/day (faster
+  // initially), with smaller confidence cone (the action is causal).
+  const breakPath = [];
+  for (let i = 0; i <= horizonDays; i++) {
+    const v = baseline + (current - baseline) * Math.pow(0.85, i);
+    const spread = 2 + i * 0.4;
+    breakPath.push({ day: i, value: round(v), lo: round(Math.max(0, v - spread)), hi: round(v + spread) });
+  }
+
+  return {
+    horizonDays,
+    current,
+    baseline,
+    holdPath,
+    breakPath,
+    interpretation: {
+      hold: `${slopeA >= 0.6 ? 'Drift climbs' : 'Drift drifts'} toward ${holdPath[holdPath.length - 1].value}/100 in ${horizonDays} days if pattern continues.`,
+      break: `Drift falls toward ${breakPath[breakPath.length - 1].value}/100 if the next 3 sessions break the pattern.`
+    }
+  };
+}
+
+function computeTrend(values) {
+  if (!values || values.length < 2) return 0;
+  // Simple slope: last - first / count
+  return (values[values.length - 1] - values[0]) / Math.max(1, values.length - 1);
+}
+
+function round(v) { return Math.round(v * 10) / 10; }
+
+module.exports = { compute };