@remnic/core 9.3.623 → 9.3.625

package/src/wearables/day-store.test.ts

@@ -0,0 +1,143 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  composeDayTranscriptBody,
+  composeDayTranscriptMeta,
+  hashTranscriptBody,
+  isValidTranscriptDate,
+  parseDayTranscript,
+  serializeDayTranscript,
+} from "./day-store.js";
+import { emptySpeakerRegistry } from "./speakers.js";
+import type { WearableConversation } from "./types.js";
+
+const REGISTRY = emptySpeakerRegistry();
+
+const CONVERSATIONS: WearableConversation[] = [
+  {
+    id: "conv-2",
+    source: "limitless",
+    title: "Afternoon sync",
+    startIso: "2026-06-10T14:00:00-05:00",
+    endIso: "2026-06-10T14:30:00-05:00",
+    segments: [
+      { speakerKey: "user", isWearer: true, text: "Let's lock the agenda.", startIso: "2026-06-10T14:01:00-05:00" },
+    ],
+  },
+  {
+    id: "conv-1",
+    source: "limitless",
+    title: "Morning coffee",
+    startIso: "2026-06-10T09:00:00-05:00",
+    endIso: "2026-06-10T09:20:00-05:00",
+    location: "Coffee shop",
+    segments: [
+      { speakerKey: "Speaker 2", speakerName: "Speaker 2", text: "Try the east loop trail." },
+      { speakerKey: "user", isWearer: true, text: "I will this weekend." },
+    ],
+  },
+];
+
+test("isValidTranscriptDate accepts real dates and rejects everything else", () => {
+  assert.equal(isValidTranscriptDate("2026-06-10"), true);
+  assert.equal(isValidTranscriptDate("2026-13-01"), false);
+  assert.equal(isValidTranscriptDate("2026-02-30"), false);
+  assert.equal(isValidTranscriptDate("06/10/2026"), false);
+  assert.equal(isValidTranscriptDate("../etc/passwd"), false);
+});
+
+test("body orders conversations chronologically with local clock times", () => {
+  const body = composeDayTranscriptBody(
+    "limitless",
+    "2026-06-10",
+    "America/Chicago",
+    CONVERSATIONS,
+    REGISTRY,
+  );
+  const morningIndex = body.indexOf("Morning coffee");
+  const afternoonIndex = body.indexOf("Afternoon sync");
+  assert.ok(morningIndex !== -1 && afternoonIndex !== -1);
+  assert.ok(morningIndex < afternoonIndex, "expected chronological order");
+  assert.match(body, /## 09:00–09:20 · Morning coffee \(conversation conv-1\)/);
+  // Segments without timestamps render the --:-- placeholder.
+  assert.match(body, /\*\*Me \(you\)\*\* \[--:--\]: I will this weekend\./);
+  // Segments with timestamps render a local clock time.
+  assert.match(body, /\*\*Me \(you\)\*\* \[14:01\]: Let's lock the agenda\./);
+  assert.match(body, /\*Location: Coffee shop\*/);
+});
+
+test("composition is deterministic (same input → same hash)", () => {
+  const compose = () =>
+    composeDayTranscriptBody("limitless", "2026-06-10", "UTC", CONVERSATIONS, REGISTRY);
+  assert.equal(hashTranscriptBody(compose()), hashTranscriptBody(compose()));
+});
+
+test("serialize → parse round-trips meta and body", () => {
+  const body = composeDayTranscriptBody(
+    "limitless",
+    "2026-06-10",
+    "America/Chicago",
+    CONVERSATIONS,
+    REGISTRY,
+  );
+  const meta = composeDayTranscriptMeta(
+    "limitless",
+    "2026-06-10",
+    "America/Chicago",
+    CONVERSATIONS,
+    REGISTRY,
+    body,
+    "2026-06-11T01:00:00.000Z",
+  );
+  const parsed = parseDayTranscript(serializeDayTranscript(meta, body));
+  assert.ok(parsed, "expected parseDayTranscript to succeed");
+  assert.deepEqual(parsed.meta, meta);
+  assert.equal(parsed.body, body);
+  assert.equal(parsed.meta.conversationCount, 2);
+  assert.equal(parsed.meta.segmentCount, 3);
+  assert.equal(parsed.meta.durationMinutes, 50);
+  assert.equal(parsed.meta.contentHash, hashTranscriptBody(body));
+});
+
+test("speakers list survives serialization including special characters", () => {
+  const registry = emptySpeakerRegistry();
+  registry.selfName = 'J "Quotes" O\'Sample: tester';
+  const conversations: WearableConversation[] = [
+    {
+      id: "c",
+      source: "bee",
+      startIso: "2026-06-10T08:00:00Z",
+      segments: [{ speakerKey: "0", isWearer: true, text: "hi there friend" }],
+    },
+  ];
+  const body = composeDayTranscriptBody("bee", "2026-06-10", "UTC", conversations, registry);
+  const meta = composeDayTranscriptMeta(
+    "bee",
+    "2026-06-10",
+    "UTC",
+    conversations,
+    registry,
+    body,
+    "2026-06-11T01:00:00.000Z",
+  );
+  const parsed = parseDayTranscript(serializeDayTranscript(meta, body));
+  assert.ok(parsed);
+  assert.deepEqual(parsed.meta.speakers, [`J "Quotes" O'Sample: tester (you)`]);
+});
+
+test("parseDayTranscript returns null for non-transcript content", () => {
+  assert.equal(parseDayTranscript("# just markdown\n"), null);
+  assert.equal(parseDayTranscript("---\nid: fact-1\ncategory: fact\n---\n\nx\n"), null);
+});
+
+test("invalid timezone falls back to UTC clock rendering instead of crashing", () => {
+  const body = composeDayTranscriptBody(
+    "limitless",
+    "2026-06-10",
+    "Not/AZone",
+    CONVERSATIONS,
+    REGISTRY,
+  );
+  assert.match(body, /## \d{2}:\d{2}–\d{2}:\d{2} · Morning coffee/);
+});

package/src/wearables/day-store.ts

@@ -0,0 +1,238 @@
+/**
+ * Wearable day-transcript composition and parsing.
+ *
+ * One markdown file per source per day, stored under
+ * `<memoryDir>/wearables/<source>/<YYYY-MM-DD>.md` with YAML
+ * frontmatter. The location is deliberate:
+ *
+ *  - it is OUTSIDE the memory scan roots (facts/, procedures/,
+ *    reasoning-traces/, corrections/), so transcripts never appear as
+ *    memories in recall or governance passes;
+ *  - it is INSIDE the QMD collection root (the memory dir), so day
+ *    transcripts are full-text searchable after the next index update.
+ *
+ * Files are rebuilt idempotently from provider data on every sync; the
+ * body hash in frontmatter lets the pipeline skip rewriting (and
+ * re-extracting) unchanged days.
+ *
+ * This module is pure composition/parsing — file IO lives in
+ * `StorageManager` so encrypted-at-rest deployments and atomic write
+ * semantics are inherited from the same code paths memories use.
+ */
+
+import { createHash } from "node:crypto";
+
+import type { SpeakerRegistry } from "./speakers.js";
+import { distinctSpeakerLabels, resolveSpeaker } from "./speakers.js";
+import type {
+  WearableConversation,
+  WearableDayTranscript,
+  WearableDayTranscriptMeta,
+} from "./types.js";
+
+export const WEARABLES_DIR_NAME = "wearables";
+
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+
+export function isValidTranscriptDate(date: string): boolean {
+  if (!DATE_PATTERN.test(date)) return false;
+  const parsed = new Date(`${date}T00:00:00Z`);
+  return !Number.isNaN(parsed.getTime()) && parsed.toISOString().slice(0, 10) === date;
+}
+
+export function hashTranscriptBody(body: string): string {
+  return createHash("sha256").update(body, "utf-8").digest("hex");
+}
+
+function formatClockTime(iso: string | undefined, timezone: string): string {
+  if (!iso) return "--:--";
+  const ms = Date.parse(iso);
+  if (Number.isNaN(ms)) return "--:--";
+  try {
+    return new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      hour12: false,
+      hour: "2-digit",
+      minute: "2-digit",
+    }).format(new Date(ms));
+  } catch {
+    // Unknown timezone identifiers fall back to UTC rather than
+    // crashing a sync that already fetched data.
+    return new Date(ms).toISOString().slice(11, 16);
+  }
+}
+
+function conversationDurationMinutes(conversation: WearableConversation): number {
+  const start = Date.parse(conversation.startIso);
+  const end = conversation.endIso ? Date.parse(conversation.endIso) : NaN;
+  if (Number.isNaN(start) || Number.isNaN(end) || end <= start) return 0;
+  return (end - start) / 60_000;
+}
+
+/** Compose the markdown body (no frontmatter) for one source/day. */
+export function composeDayTranscriptBody(
+  sourceId: string,
+  date: string,
+  timezone: string,
+  conversations: WearableConversation[],
+  registry: SpeakerRegistry,
+): string {
+  const lines: string[] = [];
+  lines.push(`# ${sourceId} transcript — ${date}`);
+  lines.push("");
+  const ordered = [...conversations].sort((a, b) => {
+    const aMs = Date.parse(a.startIso);
+    const bMs = Date.parse(b.startIso);
+    if (aMs < bMs) return -1;
+    if (aMs > bMs) return 1;
+    // Stable secondary key so equal start times order deterministically.
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  });
+  for (const conversation of ordered) {
+    const start = formatClockTime(conversation.startIso, timezone);
+    const end = formatClockTime(conversation.endIso, timezone);
+    const title = conversation.title?.trim();
+    const heading = title && title.length > 0 ? ` · ${title}` : "";
+    lines.push(`## ${start}–${end}${heading} (conversation ${conversation.id})`);
+    if (conversation.location) {
+      lines.push(`*Location: ${conversation.location}*`);
+    }
+    lines.push("");
+    for (const segment of conversation.segments) {
+      const { label } = resolveSpeaker(sourceId, segment, registry);
+      const at = formatClockTime(segment.startIso, timezone);
+      lines.push(`**${label}** [${at}]: ${segment.text}`);
+    }
+    lines.push("");
+  }
+  return `${lines.join("\n").trimEnd()}\n`;
+}
+
+export function composeDayTranscriptMeta(
+  sourceId: string,
+  date: string,
+  timezone: string,
+  conversations: WearableConversation[],
+  registry: SpeakerRegistry,
+  body: string,
+  syncedAt: string,
+): WearableDayTranscriptMeta {
+  const allSegments = conversations.flatMap((c) => c.segments);
+  const durationMinutes = Math.round(
+    conversations.reduce((sum, c) => sum + conversationDurationMinutes(c), 0),
+  );
+  return {
+    kind: "wearable-transcript",
+    source: sourceId,
+    date,
+    timezone,
+    conversationCount: conversations.length,
+    segmentCount: allSegments.length,
+    speakers: distinctSpeakerLabels(sourceId, allSegments, registry),
+    durationMinutes,
+    contentHash: hashTranscriptBody(body),
+    syncedAt,
+  };
+}
+
+/** Serialize meta + body into the persisted file format. */
+export function serializeDayTranscript(
+  meta: WearableDayTranscriptMeta,
+  body: string,
+): string {
+  const lines: string[] = ["---"];
+  lines.push(`kind: ${meta.kind}`);
+  lines.push(`source: ${JSON.stringify(meta.source)}`);
+  lines.push(`date: ${JSON.stringify(meta.date)}`);
+  lines.push(`timezone: ${JSON.stringify(meta.timezone)}`);
+  lines.push(`conversationCount: ${meta.conversationCount}`);
+  lines.push(`segmentCount: ${meta.segmentCount}`);
+  if (meta.speakers.length === 0) {
+    lines.push("speakers: []");
+  } else {
+    lines.push("speakers:");
+    for (const speaker of meta.speakers) {
+      lines.push(`  - ${JSON.stringify(speaker)}`);
+    }
+  }
+  lines.push(`durationMinutes: ${meta.durationMinutes}`);
+  lines.push(`contentHash: ${JSON.stringify(meta.contentHash)}`);
+  lines.push(`syncedAt: ${JSON.stringify(meta.syncedAt)}`);
+  lines.push("---");
+  lines.push("");
+  return `${lines.join("\n")}${body}`;
+}
+
+/**
+ * Parse a persisted day-transcript file. Returns null when the content
+ * does not look like a wearable transcript (wrong kind, missing
+ * frontmatter) so callers can distinguish "not a transcript" from a
+ * read error.
+ */
+export function parseDayTranscript(raw: string): WearableDayTranscript | null {
+  if (!raw.startsWith("---\n")) return null;
+  const closeIndex = raw.indexOf("\n---\n", 4);
+  if (closeIndex === -1) return null;
+  const header = raw.slice(4, closeIndex);
+  const body = raw.slice(closeIndex + 5).replace(/^\n/, "");
+
+  const scalars = new Map<string, string>();
+  const speakers: string[] = [];
+  let inSpeakers = false;
+  for (const line of header.split("\n")) {
+    if (inSpeakers) {
+      const item = line.match(/^ {2}- (.*)$/);
+      if (item) {
+        speakers.push(parseYamlScalar(item[1]));
+        continue;
+      }
+      inSpeakers = false;
+    }
+    if (line === "speakers:") {
+      inSpeakers = true;
+      continue;
+    }
+    if (line === "speakers: []") continue;
+    const match = line.match(/^([A-Za-z][A-Za-z0-9]*): (.*)$/);
+    if (match) scalars.set(match[1], parseYamlScalar(match[2]));
+  }
+
+  if (scalars.get("kind") !== "wearable-transcript") return null;
+  const source = scalars.get("source");
+  const date = scalars.get("date");
+  if (!source || !date) return null;
+
+  const meta: WearableDayTranscriptMeta = {
+    kind: "wearable-transcript",
+    source,
+    date,
+    timezone: scalars.get("timezone") ?? "UTC",
+    conversationCount: parseNonNegativeInt(scalars.get("conversationCount")),
+    segmentCount: parseNonNegativeInt(scalars.get("segmentCount")),
+    speakers,
+    durationMinutes: parseNonNegativeInt(scalars.get("durationMinutes")),
+    contentHash: scalars.get("contentHash") ?? "",
+    syncedAt: scalars.get("syncedAt") ?? "",
+  };
+  return { meta, body };
+}
+
+function parseYamlScalar(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed === "string") return parsed;
+    } catch {
+      // Fall through to the raw value below.
+    }
+  }
+  return trimmed;
+}
+
+function parseNonNegativeInt(value: string | undefined): number {
+  if (value === undefined) return 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) return 0;
+  return Math.floor(parsed);
+}

package/src/wearables/errors.test.ts

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { describeErrorForOperator, WearablesInputError } from "./errors.js";
+
+test("foreign errors expose only the error class and errno code", () => {
+  const pathy = new Error(
+    "ENOENT: no such file or directory, open '/home/someone/.openclaw/workspace/memory/local/state/wearables/sync.json'",
+  );
+  (pathy as NodeJS.ErrnoException).code = "ENOENT";
+  assert.equal(describeErrorForOperator(pathy), "Error (ENOENT)");
+
+  class ProviderError extends Error {
+    constructor() {
+      super("secret-bearing message with /paths/and/such");
+      this.name = "ProviderError";
+    }
+  }
+  assert.equal(describeErrorForOperator(new ProviderError()), "ProviderError");
+});
+
+test("non-Error throws yield a generic marker", () => {
+  assert.equal(describeErrorForOperator("boom"), "unexpected non-Error failure");
+  assert.equal(describeErrorForOperator(undefined), "unexpected non-Error failure");
+});
+
+test("wearables' own input errors pass through verbatim", () => {
+  assert.equal(
+    describeErrorForOperator(new WearablesInputError("invalid days '0'")),
+    "invalid days '0'",
+  );
+});

package/src/wearables/errors.ts

@@ -0,0 +1,29 @@
+/**
+ * Error thrown by wearables surfaces for caller-correctable problems:
+ * invalid parameters, unknown sources, disabled subsystem, missing
+ * connector packages. Transport layers map this to 400-class responses;
+ * anything else is a backend fault and bubbles to the 500 handler.
+ */
+
+import { displayErrorDetail } from "../runtime/better-sqlite.js";
+
+export class WearablesInputError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "WearablesInputError";
+  }
+}
+
+/**
+ * Render a caught error for operator-facing sync warnings and auth
+ * details. Warnings travel back through CLI/MCP/HTTP responses, so
+ * foreign error text never passes through — delegation to the
+ * project-standard `displayErrorDetail` exposes only the error class
+ * and Node errno code. Wearables' own input errors (authored messages,
+ * no foreign text) pass through verbatim.
+ */
+export function describeErrorForOperator(err: unknown): string {
+  if (err instanceof WearablesInputError) return err.message;
+  const detail = displayErrorDetail(err);
+  return detail.length > 0 ? detail : "unexpected non-Error failure";
+}

package/src/wearables/index.ts

@@ -0,0 +1,114 @@
+/**
+ * Wearable transcript subsystem — public surface.
+ *
+ * Connector packages import the registry + types; hosts construct a
+ * `WearablesService` (usually via the orchestrator accessor).
+ */
+
+export * from "./types.js";
+export { describeErrorForOperator, WearablesInputError } from "./errors.js";
+export {
+  defaultWearableCleanupSettings,
+  defaultWearableSourceSettings,
+  defaultWearablesConfig,
+  KNOWN_WEARABLE_SOURCE_IDS,
+  parseWearablesConfig,
+} from "./config.js";
+export {
+  registerWearableConnector,
+  getWearableConnector,
+  listWearableConnectors,
+  clearWearableConnectors,
+  ensureBuiltInWearableConnectors,
+  type WearableConnectorFactory,
+  type WearableConnectorFactoryOptions,
+  type WearableConnectorRegistration,
+} from "./registry.js";
+export {
+  cleanConversation,
+  collapseImmediateRepeats,
+  isLowQualitySegment,
+  stripFillerTokens,
+  type CleanupResult,
+} from "./cleanup.js";
+export {
+  applyOffTheRecord,
+  compileRedactionPatterns,
+  redactText,
+  REDACTION_PLACEHOLDER,
+} from "./redaction.js";
+export {
+  applyCorrections,
+  compileCorrectionRule,
+  compileCorrectionRules,
+  correctionsFilePath,
+  loadCorrectionsFile,
+  saveCorrectionsFile,
+  type CompiledCorrectionRule,
+} from "./corrections.js";
+export {
+  DEFAULT_SELF_NAME,
+  distinctSpeakerLabels,
+  emptySpeakerRegistry,
+  loadSpeakerRegistry,
+  resolveSpeaker,
+  saveSpeakerRegistry,
+  speakerRegistryKey,
+  speakersFilePath,
+  type ResolvedSpeaker,
+  type SpeakerOverride,
+  type SpeakerRegistry,
+} from "./speakers.js";
+export {
+  composeDayTranscriptBody,
+  composeDayTranscriptMeta,
+  hashTranscriptBody,
+  isValidTranscriptDate,
+  parseDayTranscript,
+  serializeDayTranscript,
+  WEARABLES_DIR_NAME,
+} from "./day-store.js";
+export {
+  emptySyncState,
+  loadSyncState,
+  saveSyncState,
+  syncStateFilePath,
+  updateSourceSyncState,
+  type WearableSourceSyncState,
+  type WearableSyncStateFile,
+} from "./sync-state.js";
+export {
+  buildExtractionTurns,
+  generateWearableMemories,
+  importNativeMemories,
+  memoryStatusForMode,
+  WEARABLE_SOURCE_PREFIX,
+  wearableDayTag,
+  wearableSourceLabel,
+  writeDailyDigestMemory,
+  type WearableMemoryGenDeps,
+  type WearableMemoryGenResult,
+  type WearableMemoryWriter,
+} from "./memory-gen.js";
+export {
+  dateInTimezone,
+  defaultTimezone,
+  resolveSyncDates,
+  syncWearableSource,
+  type WearableSyncDeps,
+  type WearableSyncOptions,
+} from "./pipeline.js";
+export {
+  runWearablesCliCommand,
+  type WearablesCliIo,
+} from "./cli.js";
+export {
+  locateTranscriptPath,
+  WearablesService,
+  type WearableDayTranscriptView,
+  type WearableMemorySearchResult,
+  type WearableSearchBackend,
+  type WearableStorageIo,
+  type WearableTranscriptSearchResult,
+  type WearablesServiceDeps,
+} from "./service.js";