openclaw-node-harness 2.0.0

package/mission-control/src/lib/memory/wikilinks.ts

@@ -0,0 +1,147 @@
+/**
+ * Wikilink extraction and smart cross-reference detection.
+ * Pure functions — no DB dependency.
+ */
+
+/** Extract all [[wikilink]] targets from markdown content, ignoring code blocks. */
+export function extractWikilinks(content: string): string[] {
+  const cleaned = stripCode(content);
+  const regex = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+  const targets: string[] = [];
+  let match;
+  while ((match = regex.exec(cleaned)) !== null) {
+    const target = match[1].trim();
+    if (target.length > 0 && target.length < 200) {
+      targets.push(target);
+    }
+  }
+  return [...new Set(targets)];
+}
+
+/** Extract task IDs like ARCANE-M01, T-20260305-001 */
+export function extractTaskIds(content: string): string[] {
+  const cleaned = stripCode(content);
+  const regex = /\b(ARCANE-[A-Z0-9]+(?:-\d+)?|T-\d{8}-\d+)\b/g;
+  const ids: string[] = [];
+  let match;
+  while ((match = regex.exec(cleaned)) !== null) {
+    ids.push(match[1]);
+  }
+  return [...new Set(ids)];
+}
+
+/** Extract file references — paths ending in known extensions mentioned in text */
+export function extractFileRefs(content: string): string[] {
+  const cleaned = stripCode(content);
+  // Match paths like: some/path/file.ext or just file.ext
+  const regex = /(?:[\w./-]+\/)?[\w.-]+\.(?:md|sol|ts|tsx|js|json|yaml|yml|pdf|txt)\b/g;
+  const refs: string[] = [];
+  let match;
+  while ((match = regex.exec(cleaned)) !== null) {
+    const ref = match[0];
+    // Skip things that are clearly not file refs
+    if (ref.includes("http") || ref.length < 4) continue;
+    refs.push(ref);
+  }
+  return [...new Set(refs)];
+}
+
+/** Strip fenced code blocks and inline code */
+function stripCode(content: string): string {
+  return content.replace(/```[\s\S]*?```/g, "").replace(/`[^`]+`/g, "");
+}
+
+export interface ResolutionMaps {
+  byPath: Map<string, string>;
+  byBasename: Map<string, string>;
+  byTitle: Map<string, string>;
+}
+
+/** Build lookup maps for resolving targets to file paths. */
+export function buildResolutionMaps(
+  docs: Array<{ filePath: string; title: string | null }>
+): ResolutionMaps {
+  const byPath = new Map<string, string>();
+  const byBasename = new Map<string, string>();
+  const byTitle = new Map<string, string>();
+
+  for (const doc of docs) {
+    byPath.set(doc.filePath, doc.filePath);
+    if (!doc.filePath.endsWith(".md")) {
+      byPath.set(doc.filePath + ".md", doc.filePath);
+    }
+
+    const basename =
+      doc.filePath.split("/").pop()?.replace(/\.md$/, "") || "";
+    if (basename) {
+      const lower = basename.toLowerCase();
+      if (!byBasename.has(lower)) {
+        byBasename.set(lower, doc.filePath);
+      }
+    }
+
+    if (doc.title) {
+      const lower = doc.title.toLowerCase();
+      if (!byTitle.has(lower)) {
+        byTitle.set(lower, doc.filePath);
+      }
+    }
+  }
+
+  return { byPath, byBasename, byTitle };
+}
+
+/** Resolve a reference to a file path. Priority: exact path → basename → title. */
+export function resolveWikilink(
+  target: string,
+  maps: ResolutionMaps
+): string | null {
+  if (maps.byPath.has(target)) return maps.byPath.get(target)!;
+  if (maps.byPath.has(target + ".md"))
+    return maps.byPath.get(target + ".md")!;
+
+  const lower = target.toLowerCase();
+  if (maps.byBasename.has(lower)) return maps.byBasename.get(lower)!;
+  if (maps.byTitle.has(lower)) return maps.byTitle.get(lower)!;
+
+  return null;
+}
+
+/**
+ * Extract ALL cross-references from a document.
+ * Combines: [[wikilinks]], task IDs, file path mentions.
+ * Returns deduplicated list of resolved file paths.
+ */
+export function extractAllReferences(
+  content: string,
+  maps: ResolutionMaps,
+  selfPath: string
+): string[] {
+  const resolved = new Set<string>();
+
+  // 1. Explicit [[wikilinks]]
+  for (const target of extractWikilinks(content)) {
+    const r = resolveWikilink(target, maps);
+    if (r && r !== selfPath) resolved.add(r);
+  }
+
+  // 2. Task IDs → check if any doc has that as its basename or title
+  for (const taskId of extractTaskIds(content)) {
+    const r = resolveWikilink(taskId, maps);
+    if (r && r !== selfPath) resolved.add(r);
+  }
+
+  // 3. File path mentions
+  for (const fileRef of extractFileRefs(content)) {
+    const r = resolveWikilink(fileRef, maps);
+    if (r && r !== selfPath) resolved.add(r);
+    // Also try just the basename
+    const basename = fileRef.split("/").pop()?.replace(/\.\w+$/, "") || "";
+    if (basename) {
+      const r2 = resolveWikilink(basename, maps);
+      if (r2 && r2 !== selfPath) resolved.add(r2);
+    }
+  }
+
+  return [...resolved];
+}

package/mission-control/src/lib/nats.ts

@@ -0,0 +1,126 @@
+import { connect, NatsConnection, StringCodec, type KV } from "nats";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// ── Singleton state (globalThis survives Next.js hot-reload) ─────────────
+// In dev mode, Turbopack re-evaluates modules on change, wiping module-level
+// variables. Using globalThis keeps the NATS connection alive across reloads.
+
+interface NatsGlobals {
+  __nats_nc?: NatsConnection | null;
+  __nats_connectingSince?: number | null;
+  __nats_healthKv?: KV | null;
+}
+
+const g = globalThis as unknown as NatsGlobals;
+
+const sc = StringCodec();
+
+const CONNECT_TIMEOUT_MS = 10_000;
+const NATS_FALLBACK = "nats://127.0.0.1:4222";
+
+/**
+ * Resolve NATS URL using the same 3-step chain as mesh.js and agent.js:
+ *   1. $OPENCLAW_NATS env var (set by launchd/systemd service definitions)
+ *   2. ~/.openclaw/openclaw.env file (user-editable, persists across sessions)
+ *   3. Hardcoded IP fallback (not hostname — MagicDNS is unreliable)
+ */
+function resolveNatsUrl(): string {
+  if (process.env.OPENCLAW_NATS) return process.env.OPENCLAW_NATS;
+  try {
+    const envFile = join(homedir(), ".openclaw", "openclaw.env");
+    if (existsSync(envFile)) {
+      const content = readFileSync(envFile, "utf8");
+      const match = content.match(/^\s*OPENCLAW_NATS\s*=\s*(.+)/m);
+      if (match && match[1].trim()) return match[1].trim();
+    }
+  } catch {
+    // File unreadable — fall through
+  }
+  return NATS_FALLBACK;
+}
+
+const NATS_URL = resolveNatsUrl();
+
+// KV bucket name — nodes write here, MC reads
+const HEALTH_BUCKET = "MESH_NODE_HEALTH";
+
+/**
+ * Get or create a singleton NATS connection.
+ * Returns null if NATS is unreachable — MC degrades gracefully.
+ */
+export async function getNats(): Promise<NatsConnection | null> {
+  if (g.__nats_nc && !g.__nats_nc.isClosed()) return g.__nats_nc;
+
+  // Reset stale guard (self-heal if previous attempt hung)
+  if (g.__nats_connectingSince && Date.now() - g.__nats_connectingSince > CONNECT_TIMEOUT_MS) {
+    console.warn("[nats] connecting guard stale, resetting");
+    g.__nats_connectingSince = null;
+  }
+  if (g.__nats_connectingSince) return null;
+
+  g.__nats_connectingSince = Date.now();
+  try {
+    g.__nats_nc = await connect({
+      servers: NATS_URL,
+      name: "mission-control",
+      reconnect: true,
+      maxReconnectAttempts: -1,
+      reconnectTimeWait: 2000,
+      reconnectJitter: 1000,
+      timeout: 5000,
+    });
+    console.log("[nats] connected to", NATS_URL);
+
+    // Reset KV handle on reconnect so it's re-fetched fresh
+    g.__nats_healthKv = null;
+
+    g.__nats_nc.closed().then(() => {
+      console.log("[nats] connection closed — will reconnect on next request");
+      g.__nats_nc = null;
+      g.__nats_healthKv = null;
+    }).catch(() => {
+      g.__nats_nc = null;
+      g.__nats_healthKv = null;
+    });
+
+    return g.__nats_nc;
+  } catch (err) {
+    console.error("[nats] connection failed:", (err as Error).message);
+    g.__nats_nc = null;
+    return null;
+  } finally {
+    g.__nats_connectingSince = null;
+  }
+}
+
+/**
+ * Get the MESH_NODE_HEALTH KV bucket (JetStream).
+ *
+ * Nodes write their health to keys like "moltymac" or "calos" every 15s.
+ * MC reads from here — no synchronous round-trip, no timeout races.
+ *
+ * Creates the bucket on first call if it doesn't exist (idempotent).
+ * Returns null if NATS is unavailable.
+ */
+export async function getHealthKv(): Promise<KV | null> {
+  if (g.__nats_healthKv) return g.__nats_healthKv;
+
+  const conn = await getNats();
+  if (!conn) return null;
+
+  try {
+    const js = conn.jetstream();
+    g.__nats_healthKv = await js.views.kv(HEALTH_BUCKET, {
+      history: 1,
+      ttl: 120_000,
+    });
+    return g.__nats_healthKv;
+  } catch (err) {
+    console.error("[nats] KV bucket error:", (err as Error).message);
+    return null;
+  }
+}
+
+export { sc, StringCodec };

package/mission-control/src/lib/parsers/clawvault-doc.ts

@@ -0,0 +1,98 @@
+import fs from "fs";
+import path from "path";
+import matter from "gray-matter";
+
+/* ------------------------------------------------------------------ */
+/*  Types                                                              */
+/* ------------------------------------------------------------------ */
+
+export interface VaultDocument {
+  filePath: string;
+  category: string;     // from directory name (preferences, decisions, etc.)
+  title: string;        // from frontmatter or filename
+  date: string | null;
+  frontmatter: Record<string, unknown>;
+  content: string;      // markdown body after frontmatter
+  modifiedAt: string;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Parser                                                             */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Parse a single ClawVault document with YAML frontmatter.
+ *
+ * Throws if the file does not exist.
+ */
+export function parseVaultDocument(filePath: string): VaultDocument {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Vault document not found: ${filePath}`);
+  }
+
+  const raw = fs.readFileSync(filePath, "utf-8");
+  const stat = fs.statSync(filePath);
+  const { data: frontmatter, content } = matter(raw);
+
+  // Category from the parent directory name
+  const category = path.basename(path.dirname(filePath));
+
+  // Title: prefer frontmatter.title, fall back to filename without extension
+  const title =
+    typeof frontmatter.title === "string" && frontmatter.title
+      ? frontmatter.title
+      : path.basename(filePath, ".md");
+
+  // Date: prefer frontmatter.date as string
+  let date: string | null = null;
+  if (frontmatter.date) {
+    if (frontmatter.date instanceof Date) {
+      date = frontmatter.date.toISOString().slice(0, 10);
+    } else if (typeof frontmatter.date === "string") {
+      date = frontmatter.date;
+    }
+  }
+
+  return {
+    filePath,
+    category,
+    title,
+    date,
+    frontmatter,
+    content,
+    modifiedAt: stat.mtime.toISOString(),
+  };
+}
+
+/* ------------------------------------------------------------------ */
+/*  Listing                                                            */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Read `.clawvault-index.json` and return all document paths with their
+ * categories.  Template files are skipped.
+ */
+export function listVaultDocuments(
+  indexPath: string
+): Array<{ path: string; category: string }> {
+  if (!fs.existsSync(indexPath)) {
+    return [];
+  }
+
+  const raw = fs.readFileSync(indexPath, "utf-8");
+  let index: { documents?: Array<{ path: string; category: string }> };
+
+  try {
+    index = JSON.parse(raw);
+  } catch {
+    throw new Error(`Failed to parse ClawVault index: ${indexPath}`);
+  }
+
+  if (!Array.isArray(index.documents)) {
+    return [];
+  }
+
+  return index.documents
+    .filter((doc) => doc.category !== "templates")
+    .map((doc) => ({ path: doc.path, category: doc.category }));
+}

package/mission-control/src/lib/parsers/daily-log.ts

@@ -0,0 +1,73 @@
+import fs from "fs";
+import path from "path";
+
+/* ------------------------------------------------------------------ */
+/*  Types                                                              */
+/* ------------------------------------------------------------------ */
+
+export interface DailyLogEntry {
+  filePath: string;
+  date: string;       // YYYY-MM-DD extracted from filename
+  title: string;      // first # heading, or the date
+  content: string;    // full markdown content
+  modifiedAt: string; // file mtime as ISO string
+}
+
+/* ------------------------------------------------------------------ */
+/*  Parser                                                             */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Parse a single daily memory log file (e.g. `memory/2026-02-18.md`).
+ *
+ * Throws if the file does not exist.
+ */
+export function parseDailyLog(filePath: string): DailyLogEntry {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Daily log not found: ${filePath}`);
+  }
+
+  const content = fs.readFileSync(filePath, "utf-8");
+  const stat = fs.statSync(filePath);
+  const basename = path.basename(filePath, ".md");
+
+  // Extract date from filename (YYYY-MM-DD)
+  const dateMatch = basename.match(/^(\d{4}-\d{2}-\d{2})$/);
+  const date = dateMatch ? dateMatch[1] : basename;
+
+  // Extract first H1 heading as title, fallback to date
+  const headingMatch = content.match(/^#\s+(.+)$/m);
+  const title = headingMatch ? headingMatch[1].trim() : date;
+
+  return {
+    filePath,
+    date,
+    title,
+    content,
+    modifiedAt: stat.mtime.toISOString(),
+  };
+}
+
+/* ------------------------------------------------------------------ */
+/*  Listing                                                            */
+/* ------------------------------------------------------------------ */
+
+/**
+ * List all daily log files in the given memory directory, sorted by
+ * filename (ascending chronological order).
+ *
+ * Returns absolute file paths matching the `YYYY-MM-DD.md` pattern.
+ */
+export function listDailyLogs(memoryDir: string): string[] {
+  if (!fs.existsSync(memoryDir)) {
+    return [];
+  }
+
+  const DATE_RE = /^\d{4}-\d{2}-\d{2}\.md$/;
+
+  return fs
+    .readdirSync(memoryDir)
+    .filter((f) => DATE_RE.test(f))
+    .sort()
+    .map((f) => path.join(memoryDir, f));
+}

package/mission-control/src/lib/parsers/memory-md.ts

@@ -0,0 +1,81 @@
+import fs from "fs";
+
+/* ------------------------------------------------------------------ */
+/*  Types                                                              */
+/* ------------------------------------------------------------------ */
+
+export interface MemorySection {
+  heading: string;
+  content: string;
+}
+
+export interface LongTermMemory {
+  filePath: string;
+  title: string;
+  sections: MemorySection[];
+  fullContent: string;
+  modifiedAt: string;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Parser                                                             */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Parse MEMORY.md into a title, structured sections, and the raw content.
+ *
+ * Sections are split on `## ` headings.  The H1 heading becomes the title.
+ *
+ * Throws if the file does not exist.
+ */
+export function parseMemoryMd(filePath: string): LongTermMemory {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Memory file not found: ${filePath}`);
+  }
+
+  const fullContent = fs.readFileSync(filePath, "utf-8");
+  const stat = fs.statSync(filePath);
+
+  // Extract title from first H1 heading
+  const titleMatch = fullContent.match(/^#\s+(.+)$/m);
+  const title = titleMatch ? titleMatch[1].trim() : "MEMORY.md";
+
+  // Split into ## sections
+  const sections: MemorySection[] = [];
+  const lines = fullContent.split("\n");
+
+  let currentHeading: string | null = null;
+  let currentLines: string[] = [];
+
+  function flush() {
+    if (currentHeading !== null) {
+      sections.push({
+        heading: currentHeading,
+        content: currentLines.join("\n").trim(),
+      });
+    }
+  }
+
+  for (const line of lines) {
+    const h2Match = line.match(/^##\s+(.+)$/);
+    if (h2Match) {
+      flush();
+      currentHeading = h2Match[1].trim();
+      currentLines = [];
+      continue;
+    }
+    if (currentHeading !== null) {
+      currentLines.push(line);
+    }
+  }
+
+  flush();
+
+  return {
+    filePath,
+    title,
+    sections,
+    fullContent,
+    modifiedAt: stat.mtime.toISOString(),
+  };
+}