mover-os 4.7.7 → 4.7.9

package/src/dashboard/lib/hook-indexer.js

@@ -0,0 +1,169 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { safeListDir, safeRead, safeStat, safeReadJson, exists } = require("./paths");
+
+// Index Mover OS hook scripts and their registration state.
+//
+// Scripts live in <bundle>/src/hooks/. We try to locate the bundle:
+//   1. Walking up from this file (lib/ → dashboard/ → src/ → bundle root)
+//   2. Default vault layout <vault>/01_Projects/Mover OS Bundle/src/hooks/
+//
+// Registration state is read from ~/.claude/settings.json hooks block.
+//
+// Last-fired timestamps come from ~/.claude/tmp/mover_<hook>_<id>.* markers.
+
+const HOOK_EVENTS = [
+  "SessionStart",
+  "Stop",
+  "PreToolUse",
+  "PostToolUse",
+  "PreCompact",
+  "UserPromptSubmit",
+  "SubagentStop",
+];
+
+function bundleHooksDir() {
+  // From src/dashboard/lib/hook-indexer.js, walk up to bundle root then into src/hooks
+  // lib/hook-indexer.js → lib → dashboard → src → bundle root
+  const candidate = path.resolve(__dirname, "..", "..", "hooks");
+  if (exists(candidate)) return candidate;
+  // Fallback: ~/.claude/hooks (if installed there)
+  const alt = path.join(os.homedir(), ".claude", "hooks");
+  if (exists(alt)) return alt;
+  return null;
+}
+
+function claudeSettingsPath() {
+  return path.join(os.homedir(), ".claude", "settings.json");
+}
+
+function claudeTmpDir() {
+  return path.join(os.homedir(), ".claude", "tmp");
+}
+
+// Extract a one-line description from the first commented lines of a script.
+function extractDescription(content) {
+  if (!content) return "";
+  const lines = content.split(/\r?\n/);
+  // For .sh: lines start with #
+  // For .js: lines start with // or /* */
+  for (let i = 0; i < Math.min(20, lines.length); i++) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    if (line.startsWith("#!")) continue;
+    if (line.startsWith("'use strict")) continue;
+    // Shell comment
+    const sh = line.match(/^#\s*(.+)$/);
+    if (sh && sh[1].length > 5) return sh[1].trim().slice(0, 140);
+    // JS line comment
+    const js = line.match(/^\/\/\s*(.+)$/);
+    if (js && js[1].length > 5) return js[1].trim().slice(0, 140);
+    // JS block comment start
+    const block = line.match(/^\/\*\s*(.+?)\s*\*?\/?$/);
+    if (block && block[1].length > 5) return block[1].trim().slice(0, 140);
+  }
+  return "";
+}
+
+function readRegisteredHooks() {
+  const settings = safeReadJson(claudeSettingsPath());
+  if (!settings || !settings.hooks) return { byEvent: {}, allPaths: new Set() };
+
+  const byEvent = {};
+  const allPaths = new Set();
+
+  for (const event of Object.keys(settings.hooks)) {
+    const entries = settings.hooks[event];
+    if (!Array.isArray(entries)) continue;
+    byEvent[event] = [];
+    for (const entry of entries) {
+      // shape: { matcher?: string, hooks: [{ type, command }] }
+      const hooks = Array.isArray(entry.hooks) ? entry.hooks : [];
+      for (const h of hooks) {
+        if (typeof h.command === "string") {
+          // Extract script filename from command
+          const scriptMatch = h.command.match(/([^\s"'\/]+\.(sh|js))/i);
+          if (scriptMatch) {
+            const filename = scriptMatch[1];
+            byEvent[event].push({ filename, command: h.command, matcher: entry.matcher || null });
+            allPaths.add(filename);
+          }
+        }
+      }
+    }
+  }
+
+  return { byEvent, allPaths };
+}
+
+function readLastFired() {
+  const tmp = claudeTmpDir();
+  if (!safeStat(tmp)) return {};
+  const markers = safeListDir(tmp, { filesOnly: true });
+  const lastFired = {};
+  for (const m of markers) {
+    if (!m.name.startsWith("mover_")) continue;
+    const stat = safeStat(m.path);
+    if (!stat) continue;
+    // Marker filename heuristic: mover_<hookname>_<id>.<ext>
+    const m2 = m.name.match(/^mover_([a-z0-9-]+)_/i);
+    if (m2) {
+      const hookKey = m2[1];
+      const t = stat.mtime.getTime();
+      if (!lastFired[hookKey] || lastFired[hookKey] < t) {
+        lastFired[hookKey] = t;
+      }
+    }
+  }
+  return lastFired;
+}
+
+function indexHooks() {
+  const hooksDir = bundleHooksDir();
+  if (!hooksDir) {
+    return { available: false, count: 0, byEvent: {}, registered: [], unregistered: [] };
+  }
+
+  const entries = safeListDir(hooksDir, { filesOnly: true });
+  const scripts = entries.filter(e => e.name.endsWith(".sh") || e.name.endsWith(".js"));
+
+  const { byEvent: regByEvent, allPaths: registeredPaths } = readRegisteredHooks();
+  const lastFired = readLastFired();
+
+  const all = scripts.map(s => {
+    const content = safeRead(s.path);
+    const description = extractDescription(content);
+    const stat = safeStat(s.path);
+    const isRegistered = registeredPaths.has(s.name);
+    // Derive a "key" matching the marker convention (script stem)
+    const stem = s.name.replace(/\.(sh|js)$/, "");
+    const lastFiredAt = lastFired[stem] || null;
+
+    return {
+      filename: s.name,
+      path: s.path,
+      type: s.name.endsWith(".js") ? "js" : "sh",
+      description,
+      registered: isRegistered,
+      lastFiredAt,
+      lastModified: stat ? stat.mtime.getTime() : null,
+    };
+  });
+
+  all.sort((a, b) => a.filename.localeCompare(b.filename));
+
+  return {
+    available: true,
+    count: all.length,
+    byEvent: regByEvent,
+    registered: all.filter(h => h.registered),
+    unregistered: all.filter(h => !h.registered),
+    all,
+    events: HOOK_EVENTS,
+  };
+}
+
+module.exports = { indexHooks };

package/src/dashboard/lib/hourly-activity-parser.js

@@ -0,0 +1,143 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { dailiesDir } = require("./paths");
+const { localDateKey } = require("./date-utils");
+
+// hourly-activity-parser.js — a 24-hour readiness-curve UI pattern applied
+// to behavioral data.
+//
+// The reference pattern plots biometric readiness on a 24-hour curve. We
+// don't have biometrics in the vault — we have BEHAVIORAL ACTIVITY: how
+// often the user actually
+// works (sessions, log entries) at each hour. That density curve answers the
+// same question ("when am I sharpest?") from a different angle: when do you
+// actually get things done historically.
+//
+// Returns: { available, hours: [{ hour: 0..23, count, isPeak }], peakHour,
+//           todayHours: [{ hour, count }], events: [{ hour, text, date }] }
+//
+// Sources:
+//  - Daily Notes ### HH:MM entries inside ## Session Log sections
+//  - Last 14 days (2 full weeks for a stable curve)
+
+function compute({ vault, daysLookback = 14 } = {}) {
+  if (!vault) return { available: false, hours: [], peakHour: null, todayHours: [], events: [] };
+
+  const dDir = dailiesDir(vault);
+  if (!fs.existsSync(dDir)) return { available: false, hours: [], peakHour: null, todayHours: [], events: [] };
+
+  // Per-hour aggregated counts across the lookback window
+  const hourCounts = new Array(24).fill(0);
+  // Today's specific hour counts (for the bright overlay line)
+  const todayCounts = new Array(24).fill(0);
+  // Notable session-log events to plot as markers
+  const events = [];
+
+  const cutoff = Date.now() - daysLookback * 24 * 3600 * 1000;
+  const todayKey = localDateKey();
+
+  let monthDirs;
+  try {
+    monthDirs = fs.readdirSync(dDir).filter(d => /^\d{4}-\d{2}$/.test(d)).sort().reverse();
+  } catch (_) {
+    return { available: false, hours: [], peakHour: null, todayHours: [], events: [] };
+  }
+
+  let scanned = 0;
+  outer: for (const mDir of monthDirs) {
+    if (scanned >= daysLookback) break;
+    const monthPath = path.join(dDir, mDir);
+    let files;
+    try {
+      files = fs.readdirSync(monthPath).filter(f => /^Daily - \d{4}-\d{2}-\d{2}\.md$/.test(f)).sort().reverse();
+    } catch (_) { continue; }
+    for (const f of files) {
+      if (scanned >= daysLookback) break outer;
+      const m = f.match(/(\d{4})-(\d{2})-(\d{2})/);
+      if (!m) continue;
+      const dayKey = `${m[1]}-${m[2]}-${m[3]}`;
+      const dayTs = Date.parse(dayKey);
+      if (!Number.isFinite(dayTs) || dayTs < cutoff) continue;
+      const isToday = dayKey === todayKey;
+      scanned++;
+
+      let text;
+      try { text = fs.readFileSync(path.join(monthPath, f), "utf8"); }
+      catch (_) { continue; }
+
+      // Find the Session Log section. Mover OS uses 3 formats:
+      //   ### Session Log [ATTENDED] — ~02:03-14:37 [May 13] [Claude Code] [Mover OS Bundle] [COMPACTED]
+      //   ### Session Log [AUTO-STUB] — ~22:21 [Claude Code] [Mover OS Bundle] [hash]
+      //   ### ~14:32 - Event Title  (legacy / nested events)
+      // T242 bug hunt fix (B#11): `text.indexOf("## Session Log")` was a
+      // substring search — `### Session Log` (level 3, also valid) contains
+      // the literal `## Session Log` as a substring. Conversely, level-2
+      // `## Session Log` headers with no nested `###` sub-entries were
+      // matched by the section locator but the entries regex below
+      // returned nothing. Anchor to level-2 explicitly. Fallback: if no
+      // level-2 found, try level-3 (some daily notes use only ### form).
+      let slMatch = text.match(/^##\s+Session Log/m);
+      if (!slMatch) slMatch = text.match(/^###\s+Session Log/m);
+      if (!slMatch || typeof slMatch.index !== "number") continue;
+      const section = text.slice(slMatch.index);
+
+      // Format A: Session Log header with time range — count the START hour
+      const reSession = /^###\s+Session Log\s+\[[^\]]+\]\s+—\s+~?(\d{1,2}):(\d{2})(?:[-–]\s*(\d{1,2}):(\d{2}))?\s*(?:\[[^\]]+\])?\s*(?:\[([^\]]+)\])?/gm;
+      let mm;
+      while ((mm = reSession.exec(section)) !== null) {
+        const startHour = parseInt(mm[1], 10);
+        if (!Number.isFinite(startHour) || startHour < 0 || startHour > 23) continue;
+        hourCounts[startHour]++;
+        if (isToday) todayCounts[startHour]++;
+        const tag = mm[5] ? `[${mm[5]}]` : "";
+        const range = mm[3] ? ` ${mm[1]}:${mm[2]}-${mm[3]}:${mm[4]}` : ` ${mm[1]}:${mm[2]}`;
+        events.push({ hour: startHour, date: dayKey, text: `Session${range}${tag ? " " + tag : ""}`.trim(), isToday });
+      }
+
+      // Format B: Legacy nested event headers — `### HH:MM - Title`
+      const reLegacy = /^###\s+~?(\d{1,2}):(\d{2})\s+-\s+(.+)$/gm;
+      while ((mm = reLegacy.exec(section)) !== null) {
+        const hour = parseInt(mm[1], 10);
+        if (!Number.isFinite(hour) || hour < 0 || hour > 23) continue;
+        const title = (mm[3] || "").trim();
+        // Skip Session Log headers re-matched (they contain " — ")
+        if (title.startsWith("Session Log")) continue;
+        hourCounts[hour]++;
+        if (isToday) todayCounts[hour]++;
+        if (title.length < 80) {
+          events.push({ hour, date: dayKey, text: title, isToday });
+        }
+      }
+    }
+  }
+
+  // Compute peak hour
+  let peakHour = null;
+  let peakCount = 0;
+  for (let h = 0; h < 24; h++) {
+    if (hourCounts[h] > peakCount) {
+      peakCount = hourCounts[h];
+      peakHour = h;
+    }
+  }
+
+  const hours = hourCounts.map((c, h) => ({ hour: h, count: c, isPeak: h === peakHour && peakCount > 0 }));
+  const todayHours = todayCounts.map((c, h) => ({ hour: h, count: c }));
+
+  // Keep last 12 today-events for marker overlay
+  const todayEvents = events.filter(e => e.isToday).slice(0, 12);
+
+  return {
+    available: scanned > 0,
+    daysScanned: scanned,
+    hours,
+    peakHour,
+    peakCount,
+    todayHours,
+    events: todayEvents
+  };
+}
+
+module.exports = { compute };

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

@@ -0,0 +1,85 @@
+"use strict";
+
+const { identityPrimePath, safeRead, safeStat } = require("./paths");
+
+// Parse Identity_Prime.md. Extracts archetype, core drive, fatal flaw, the law, anti-identity, code lines.
+
+function parseIdentity(vault) {
+  const filePath = identityPrimePath(vault);
+  const text = safeRead(filePath);
+  const stat = safeStat(filePath);
+  if (!text) return { available: false, filePath };
+
+  const out = { available: true, filePath, lastUpdated: stat ? stat.mtime : null, raw: text, fields: {} };
+
+  // Bold field extraction
+  const re = /\*\*([^*]+):\*\*\s*([^\n]+)/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const k = m[1].trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_|_$/g, "");
+    out.fields[k] = m[2].trim();
+  }
+
+  // Personal name from the H1 ("# IDENTITY PRIME: <name>") — the onboarding
+  // engine-writer writes the user's own answer there. Persona titles
+  // ("THE MOVER") and the unanswered placeholder ("You") are not names.
+  const h1 = text.match(/^#[^\n]*IDENTITY PRIME:\s*(.+?)\s*$/mi);
+  const h1name = h1 ? h1[1].trim() : "";
+  out.name = h1name && !/^the\s/i.test(h1name) && h1name.toLowerCase() !== "you" ? h1name : null;
+
+  // Common keys
+  out.archetype = out.fields.archetype || null;
+  out.coreDrive = out.fields.core_drive || null;
+  out.fatalFlaw = out.fields.fatal_flaw || null;
+  out.theLaw = out.fields.the_law || null;
+  out.antiIdentity = out.fields.anti_identity || null;
+  out.psychFirewall = out.fields.psychological_firewall || null;
+
+  // Sections
+  const sections = splitSections(text);
+  out.sections = sections;
+  out.code = extractListUnder(sections, "the code");
+  out.evolvedSelf = sectionBody(sections, "evolved self");
+  out.antiIdentityBody = sectionBody(sections, "anti-identity") || sectionBody(sections, "the mediocre");
+  out.primaryResistanceForms = extractListUnder(sections, "primary resistance forms");
+
+  return out;
+}
+
+function splitSections(text) {
+  const sections = {};
+  const lines = text.split("\n");
+  let currentTitle = null;
+  let buf = [];
+  for (const line of lines) {
+    const h = line.match(/^##+\s+(.+?)\s*$/);
+    if (h) {
+      if (currentTitle) sections[currentTitle.toLowerCase()] = buf.join("\n");
+      currentTitle = h[1];
+      buf = [];
+    } else if (currentTitle) {
+      buf.push(line);
+    }
+  }
+  if (currentTitle) sections[currentTitle.toLowerCase()] = buf.join("\n");
+  return sections;
+}
+
+function sectionBody(sections, needle) {
+  for (const [title, body] of Object.entries(sections)) {
+    if (title.includes(needle.toLowerCase())) return body;
+  }
+  return null;
+}
+
+function extractListUnder(sections, needle) {
+  const body = sectionBody(sections, needle);
+  if (!body) return [];
+  return body.split("\n")
+    .map(l => l.match(/^\s*[-*\d.]+\s+(.+)$/))
+    .filter(Boolean)
+    .map(m => m[1].trim())
+    .slice(0, 12);
+}
+
+module.exports = { parseIdentity };