@openmnemo/sync 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 openmnemo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,112 @@
+import { ParsedTranscript } from '@openmnemo/types';
+
+/**
+ * Load, validate, and manage ~/.memorytree/config.toml.
+ * Port of scripts/_config_utils.py
+ */
+interface ProjectEntry {
+    readonly path: string;
+    readonly name: string;
+}
+interface Config {
+    readonly heartbeat_interval: string;
+    readonly watch_dirs: readonly string[];
+    readonly projects: readonly ProjectEntry[];
+    readonly auto_push: boolean;
+    readonly log_level: string;
+}
+declare function memorytreeRoot(): string;
+declare function configPath(): string;
+declare function loadConfig(): Config;
+declare function saveConfig(cfg: Config): void;
+declare function intervalToSeconds(interval: string): number;
+declare function registerProject(cfg: Config, repoPath: string): Config;
+
+/**
+ * MemoryTree heartbeat — single execution, stateless, idempotent.
+ * Port of scripts/heartbeat.py
+ */
+
+declare function main(): Promise<number>;
+declare function runHeartbeat(config: Config): Promise<number>;
+declare function processProject(config: Config, projectPath: string, projectName: string): Promise<void>;
+declare function scanSensitive(parsed: ParsedTranscript, projectPath: string): void;
+declare function gitCommitAndPush(config: Config, projectPath: string, projectName: string, count: number): void;
+declare function tryPush(projectPath: string, projectName: string): boolean;
+
+/**
+ * PID-based lock file for heartbeat single-instance enforcement.
+ * Port of scripts/_lock_utils.py
+ */
+declare function lockPath(): string;
+/**
+ * Try to acquire the heartbeat lock. Returns `true` on success.
+ *
+ * If the lock file already exists, the stored PID is checked:
+ * - alive process  -> return false (already running)
+ * - dead process   -> reclaim the stale lock
+ * - corrupt file   -> remove and retry
+ *
+ * Uses `O_CREAT | O_EXCL` to prevent TOCTOU races.
+ */
+declare function acquireLock(): boolean;
+/** Release the heartbeat lock. */
+declare function releaseLock(): void;
+/** Read the PID from the lock file, or `null` if not locked / corrupt. */
+declare function readLockPid(): number | null;
+/** Check whether a process with the given PID is still running. */
+declare function isProcessAlive(pid: number): boolean;
+
+/**
+ * Manage ~/.memorytree/alerts.json — append, dedup, threshold, display.
+ * Port of scripts/_alert_utils.py
+ */
+declare const MAX_ALERTS = 100;
+declare const ALERT_TYPES: ReadonlySet<string>;
+declare const FAILURE_THRESHOLD = 3;
+interface Alert {
+    readonly timestamp: string;
+    readonly project: string;
+    readonly type: string;
+    readonly message: string;
+    readonly count: number;
+    readonly [key: string]: unknown;
+}
+declare function alertsPath(): string;
+declare function readAlerts(): readonly Alert[];
+declare function writeAlert(project: string, alertType: string, message: string): void;
+declare function writeAlertWithThreshold(project: string, alertType: string, message: string): void;
+declare function resetFailureCount(project: string, alertType: string): void;
+declare function clearAlerts(): void;
+declare function formatAlertsForDisplay(alerts: readonly Record<string, unknown>[]): string;
+
+/**
+ * Logging setup for heartbeat — file output + stderr.
+ * Port of scripts/_log_utils.py
+ */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface Logger {
+    debug(msg: string): void;
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+    exception(msg: string, err?: unknown): void;
+}
+/**
+ * Create (or return existing) singleton logger.
+ *
+ * The `logLevel` parameter is only used on the *first* call.  Subsequent
+ * calls return the existing logger regardless of the level argument.
+ */
+declare function setupLogging(logLevel?: LogLevel): Logger;
+/**
+ * Return the singleton logger.  If `setupLogging` has not been called yet
+ * the logger is auto-created with default settings (`info` level).
+ */
+declare function getLogger(): Logger;
+/**
+ * Reset the singleton — primarily useful for tests.
+ */
+declare function _resetLogger(): void;
+
+export { ALERT_TYPES, type Alert, FAILURE_THRESHOLD, type LogLevel, type Logger, MAX_ALERTS, _resetLogger, acquireLock, alertsPath, clearAlerts, configPath, formatAlertsForDisplay, getLogger, gitCommitAndPush, main as heartbeatMain, intervalToSeconds, isProcessAlive, loadConfig, lockPath, memorytreeRoot, processProject, readAlerts, readLockPid, registerProject, releaseLock, resetFailureCount, runHeartbeat, saveConfig, scanSensitive, setupLogging, tryPush, writeAlert, writeAlertWithThreshold };

package/dist/index.js

@@ -0,0 +1,691 @@
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, resolve } from "path";
+import { parse as parseToml } from "smol-toml";
+import { toPosixPath } from "@openmnemo/core";
+var DEFAULT_HEARTBEAT_INTERVAL = "5m";
+var DEFAULT_AUTO_PUSH = true;
+var DEFAULT_LOG_LEVEL = "info";
+var VALID_LOG_LEVELS = /* @__PURE__ */ new Set(["debug", "info", "warn", "error"]);
+function memorytreeRoot() {
+  return resolve(homedir(), ".memorytree");
+}
+function configPath() {
+  return resolve(memorytreeRoot(), "config.toml");
+}
+function loadConfig() {
+  const path = configPath();
+  if (!existsSync(path)) {
+    return defaultConfig();
+  }
+  let raw;
+  try {
+    const text = readFileSync(path, "utf-8");
+    raw = parseToml(text);
+  } catch {
+    return defaultConfig();
+  }
+  return parseRaw(raw);
+}
+function saveConfig(cfg) {
+  const path = configPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const lines = [
+    `heartbeat_interval = ${tomlString(cfg.heartbeat_interval)}`,
+    `auto_push = ${cfg.auto_push ? "true" : "false"}`,
+    `log_level = ${tomlString(cfg.log_level)}`
+  ];
+  if (cfg.watch_dirs.length > 0) {
+    const items = cfg.watch_dirs.map((d) => tomlString(d)).join(", ");
+    lines.push(`watch_dirs = [${items}]`);
+  } else {
+    lines.push("watch_dirs = []");
+  }
+  lines.push("");
+  for (const project of cfg.projects) {
+    lines.push("[[projects]]");
+    lines.push(`path = ${tomlString(project.path)}`);
+    if (project.name) {
+      lines.push(`name = ${tomlString(project.name)}`);
+    }
+    lines.push("");
+  }
+  writeFileSync(path, lines.join("\n") + "\n", "utf-8");
+}
+function intervalToSeconds(interval) {
+  const match = interval.trim().toLowerCase().match(/^(\d+)\s*(s|m|h)$/);
+  if (!match) {
+    return intervalToSeconds(DEFAULT_HEARTBEAT_INTERVAL);
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  if (value <= 0) {
+    return intervalToSeconds(DEFAULT_HEARTBEAT_INTERVAL);
+  }
+  const multiplier = { s: 1, m: 60, h: 3600 };
+  return value * (multiplier[unit] ?? 60);
+}
+function registerProject(cfg, repoPath) {
+  const resolved = toPosixPath(resolve(repoPath));
+  for (const entry of cfg.projects) {
+    if (toPosixPath(resolve(entry.path)) === resolved) {
+      return cfg;
+    }
+  }
+  const name = resolved.split("/").pop() ?? "";
+  return {
+    ...cfg,
+    projects: [...cfg.projects, { path: resolved, name }]
+  };
+}
+function defaultConfig() {
+  return {
+    heartbeat_interval: DEFAULT_HEARTBEAT_INTERVAL,
+    watch_dirs: [],
+    projects: [],
+    auto_push: DEFAULT_AUTO_PUSH,
+    log_level: DEFAULT_LOG_LEVEL
+  };
+}
+function parseRaw(raw) {
+  let interval = raw["heartbeat_interval"];
+  if (typeof interval !== "string" || !isValidInterval(interval)) {
+    interval = DEFAULT_HEARTBEAT_INTERVAL;
+  }
+  let autoPush = raw["auto_push"];
+  if (typeof autoPush !== "boolean") {
+    autoPush = DEFAULT_AUTO_PUSH;
+  }
+  let logLevel = raw["log_level"];
+  if (typeof logLevel !== "string" || !VALID_LOG_LEVELS.has(logLevel.toLowerCase())) {
+    logLevel = DEFAULT_LOG_LEVEL;
+  }
+  logLevel = logLevel.toLowerCase();
+  const watchDirs = [];
+  const rawDirs = raw["watch_dirs"];
+  if (Array.isArray(rawDirs)) {
+    for (const d of rawDirs) {
+      if (typeof d === "string") watchDirs.push(d);
+    }
+  }
+  const projects = [];
+  const rawProjects = raw["projects"];
+  if (Array.isArray(rawProjects)) {
+    for (const entry of rawProjects) {
+      if (entry !== null && typeof entry === "object" && !Array.isArray(entry)) {
+        const rec = entry;
+        if (typeof rec["path"] === "string") {
+          projects.push({
+            path: rec["path"],
+            name: String(rec["name"] ?? "")
+          });
+        }
+      }
+    }
+  }
+  return {
+    heartbeat_interval: interval,
+    watch_dirs: watchDirs,
+    projects,
+    auto_push: autoPush,
+    log_level: logLevel
+  };
+}
+function isValidInterval(value) {
+  const match = value.trim().toLowerCase().match(/^(\d+)\s*(s|m|h)$/);
+  if (!match) return false;
+  return parseInt(match[1], 10) > 0;
+}
+function tomlString(value) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+
+// src/heartbeat.ts
+import { discoverSourceFiles, transcriptMatchesRepo } from "@openmnemo/core";
+import { importTranscript, transcriptHasContent } from "@openmnemo/core";
+import { parseTranscript } from "@openmnemo/core";
+import { slugify } from "@openmnemo/core";
+import { defaultGlobalTranscriptRoot } from "@openmnemo/core";
+
+// src/lock.ts
+import {
+  closeSync,
+  constants,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readFileSync as readFileSync2,
+  unlinkSync,
+  writeSync
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { execFileSync } from "child_process";
+function lockPath() {
+  return resolve2(homedir2(), ".memorytree", "heartbeat.lock");
+}
+function acquireLock() {
+  const path = lockPath();
+  mkdirSync2(dirname2(path), { recursive: true });
+  if (existsSync2(path)) {
+    let storedPid;
+    try {
+      const raw = readFileSync2(path, "utf-8").trim();
+      storedPid = parseInt(raw, 10);
+      if (!Number.isFinite(storedPid)) {
+        storedPid = void 0;
+      }
+    } catch {
+      storedPid = void 0;
+    }
+    if (storedPid === void 0) {
+      removeLockFile(path);
+    } else {
+      if (isProcessAlive(storedPid)) {
+        return false;
+      }
+      removeLockFile(path);
+    }
+  }
+  try {
+    const fd = openSync(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
+    const pidBytes = Buffer.from(String(process.pid), "utf-8");
+    writeSync(fd, pidBytes);
+    closeSync(fd);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function releaseLock() {
+  removeLockFile(lockPath());
+}
+function readLockPid() {
+  const path = lockPath();
+  if (!existsSync2(path)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync2(path, "utf-8").trim();
+    const pid = parseInt(raw, 10);
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  if (pid <= 0) {
+    return false;
+  }
+  if (process.platform === "win32") {
+    return isProcessAliveWindows(pid);
+  }
+  return isProcessAliveUnix(pid);
+}
+function isProcessAliveUnix(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err instanceof Error && "code" in err) {
+      if (err.code === "EPERM") {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+function isProcessAliveWindows(pid) {
+  try {
+    const output = execFileSync("tasklist", ["/FI", `PID eq ${pid}`, "/NH"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      windowsHide: true
+    });
+    return new RegExp(`\\b${pid}\\b`).test(output);
+  } catch {
+    return false;
+  }
+}
+function removeLockFile(path) {
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+}
+
+// src/alert.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname3, resolve as resolve3 } from "path";
+var MAX_ALERTS = 100;
+var ALERT_TYPES = /* @__PURE__ */ new Set([
+  "no_remote",
+  "sensitive_match",
+  "push_failed",
+  "lock_held"
+]);
+var FAILURE_THRESHOLD = 3;
+function alertsPath() {
+  return resolve3(homedir3(), ".memorytree", "alerts.json");
+}
+function failureStatePath() {
+  return resolve3(homedir3(), ".memorytree", "failure_counts.json");
+}
+function utcTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function readAlerts() {
+  const path = alertsPath();
+  if (!existsSync3(path)) {
+    return [];
+  }
+  try {
+    const text = readFileSync3(path, "utf-8");
+    const data = JSON.parse(text);
+    if (!Array.isArray(data)) {
+      return [];
+    }
+    return data;
+  } catch {
+    return [];
+  }
+}
+function writeAlert(project, alertType, message) {
+  const alerts = readAlerts();
+  const now = utcTimestamp();
+  let found = false;
+  const updated = [];
+  for (const alert of alerts) {
+    if (alert.project === project && alert.type === alertType) {
+      updated.push({
+        ...alert,
+        timestamp: now,
+        message,
+        count: (alert.count ?? 1) + 1
+      });
+      found = true;
+    } else {
+      updated.push({ ...alert });
+    }
+  }
+  if (!found) {
+    updated.push({ timestamp: now, project, type: alertType, message, count: 1 });
+  }
+  const trimmed = updated.length > MAX_ALERTS ? updated.slice(updated.length - MAX_ALERTS) : updated;
+  saveAlerts(trimmed);
+}
+function writeAlertWithThreshold(project, alertType, message) {
+  const counts = readFailureCounts();
+  const key = `${project}::${alertType}`;
+  const current = (counts[key] ?? 0) + 1;
+  const newCounts = { ...counts, [key]: current };
+  saveFailureCounts(newCounts);
+  if (current >= FAILURE_THRESHOLD) {
+    writeAlert(project, alertType, message);
+  }
+}
+function resetFailureCount(project, alertType) {
+  const counts = readFailureCounts();
+  const key = `${project}::${alertType}`;
+  if (key in counts) {
+    const newCounts = {};
+    for (const [k, v] of Object.entries(counts)) {
+      if (k !== key) {
+        newCounts[k] = v;
+      }
+    }
+    saveFailureCounts(newCounts);
+  }
+}
+function clearAlerts() {
+  const path = alertsPath();
+  if (existsSync3(path)) {
+    try {
+      unlinkSync2(path);
+    } catch {
+    }
+  }
+}
+function formatAlertsForDisplay(alerts) {
+  if (alerts.length === 0) {
+    return "";
+  }
+  const lines = [];
+  for (const alert of alerts) {
+    const count = typeof alert["count"] === "number" ? alert["count"] : 1;
+    const countSuffix = count > 1 ? ` (x${String(count)})` : "";
+    const type = typeof alert["type"] === "string" ? alert["type"] : "unknown";
+    const project = typeof alert["project"] === "string" ? alert["project"] : "?";
+    const message = typeof alert["message"] === "string" ? alert["message"] : "";
+    lines.push(`  [${type}] ${project}: ${message}${countSuffix}`);
+  }
+  return lines.join("\n");
+}
+function saveAlerts(alerts) {
+  const path = alertsPath();
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync2(path, JSON.stringify(alerts, null, 2) + "\n", "utf-8");
+}
+function readFailureCounts() {
+  const path = failureStatePath();
+  if (!existsSync3(path)) {
+    return {};
+  }
+  try {
+    const text = readFileSync3(path, "utf-8");
+    const data = JSON.parse(text);
+    if (data === null || typeof data !== "object" || Array.isArray(data)) {
+      return {};
+    }
+    return data;
+  } catch {
+    return {};
+  }
+}
+function saveFailureCounts(counts) {
+  const path = failureStatePath();
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync2(path, JSON.stringify(counts, null, 2) + "\n", "utf-8");
+}
+
+// src/log.ts
+import { appendFileSync, mkdirSync as mkdirSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { resolve as resolve4 } from "path";
+var LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var LEVEL_LABELS = {
+  debug: "DEBUG",
+  info: "INFO",
+  warn: "WARN",
+  error: "ERROR"
+};
+var singleton;
+var MemoryTreeLogger = class {
+  levelPriority;
+  logFilePath;
+  constructor(logLevel) {
+    this.levelPriority = LEVEL_PRIORITY[logLevel];
+    const filePath = logFilePathForToday();
+    const logDir = resolve4(filePath, "..");
+    try {
+      mkdirSync4(logDir, { recursive: true });
+      this.logFilePath = filePath;
+    } catch {
+      this.writeStderr("WARN", `Could not open log file: ${filePath}`);
+      this.logFilePath = void 0;
+    }
+  }
+  debug(msg) {
+    this.log("debug", msg);
+  }
+  info(msg) {
+    this.log("info", msg);
+  }
+  warn(msg) {
+    this.log("warn", msg);
+  }
+  error(msg) {
+    this.log("error", msg);
+  }
+  exception(msg, err) {
+    if (err instanceof Error && err.stack) {
+      this.log("error", `${msg}
+${err.stack}`);
+    } else if (err !== void 0) {
+      this.log("error", `${msg}
+${String(err)}`);
+    } else {
+      this.log("error", msg);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Internal
+  // -----------------------------------------------------------------------
+  log(level, msg) {
+    if (LEVEL_PRIORITY[level] < this.levelPriority) {
+      return;
+    }
+    const label = LEVEL_LABELS[level];
+    const formatted = `${timestamp()} [${label}] ${msg}`;
+    this.writeStderr(label, msg);
+    this.writeFile(formatted);
+  }
+  writeStderr(_label, _msg) {
+    const line = `${timestamp()} [${_label}] ${_msg}
+`;
+    process.stderr.write(line);
+  }
+  writeFile(formatted) {
+    if (this.logFilePath === void 0) {
+      return;
+    }
+    try {
+      appendFileSync(this.logFilePath, formatted + "\n", "utf-8");
+    } catch {
+    }
+  }
+};
+function setupLogging(logLevel = "info") {
+  if (singleton !== void 0) {
+    return singleton;
+  }
+  singleton = new MemoryTreeLogger(resolveLevel(logLevel));
+  return singleton;
+}
+function getLogger() {
+  if (singleton === void 0) {
+    singleton = new MemoryTreeLogger(resolveLevel("info"));
+  }
+  return singleton;
+}
+function _resetLogger() {
+  singleton = void 0;
+}
+function resolveLevel(level) {
+  const lower = level.toLowerCase();
+  const mapping = {
+    debug: "debug",
+    info: "info",
+    warn: "warn",
+    warning: "warn",
+    error: "error"
+  };
+  return mapping[lower] ?? "info";
+}
+function logFilePathForToday() {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return resolve4(homedir4(), ".memorytree", "logs", `heartbeat-${today}.log`);
+}
+function timestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getUTCFullYear();
+  const mo = String(now.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(now.getUTCDate()).padStart(2, "0");
+  const h = String(now.getUTCHours()).padStart(2, "0");
+  const mi = String(now.getUTCMinutes()).padStart(2, "0");
+  const s = String(now.getUTCSeconds()).padStart(2, "0");
+  return `${y}-${mo}-${d}T${h}:${mi}:${s}`;
+}
+
+// src/heartbeat.ts
+import { git } from "@openmnemo/core";
+import { toPosixPath as toPosixPath2 } from "@openmnemo/core";
+import { resolve as resolve5 } from "path";
+import { existsSync as existsSync4 } from "fs";
+var SENSITIVE_PATTERNS = [
+  /(?:api[_-]?key|apikey)\s*[:=]\s*\S+/i,
+  /(?:password|passwd|pwd)\s*[:=]\s*\S+/i,
+  /(?:secret|token)\s*[:=]\s*\S+/i,
+  /(?:sk-|pk_live_|sk_live_|ghp_|gho_|glpat-)\S{10,}/,
+  /Bearer\s+\S{20,}/i
+];
+async function main() {
+  const config = loadConfig();
+  setupLogging(config.log_level);
+  const logger = getLogger();
+  if (!acquireLock()) {
+    logger.info("Another heartbeat instance is running. Exiting.");
+    writeAlert("global", "lock_held", "Heartbeat exited: another instance held the lock.");
+    return 0;
+  }
+  try {
+    return await runHeartbeat(config);
+  } finally {
+    releaseLock();
+  }
+}
+async function runHeartbeat(config) {
+  const logger = getLogger();
+  if (config.projects.length === 0) {
+    logger.info("No projects registered in config.toml. Nothing to do.");
+    return 0;
+  }
+  logger.info(`Heartbeat started. ${config.projects.length} project(s) registered.`);
+  for (const entry of config.projects) {
+    const projectPath = resolve5(entry.path);
+    if (!existsSync4(projectPath)) {
+      logger.warn(`Project path does not exist, skipping: ${projectPath}`);
+      continue;
+    }
+    try {
+      await processProject(config, projectPath, entry.name || (projectPath.split(/[/\\]/).pop() ?? ""));
+    } catch (err) {
+      logger.exception(`Error processing project: ${projectPath}`, err);
+      writeAlertWithThreshold(
+        toPosixPath2(projectPath),
+        "push_failed",
+        `Heartbeat error for project: ${projectPath.split(/[/\\]/).pop() ?? ""}`
+      );
+    }
+  }
+  logger.info("Heartbeat finished.");
+  return 0;
+}
+async function processProject(config, projectPath, projectName) {
+  const logger = getLogger();
+  const repoSlug = slugify(projectName, "project");
+  const globalRoot = defaultGlobalTranscriptRoot();
+  const discovered = discoverSourceFiles();
+  let importedCount = 0;
+  for (const [client, source] of discovered) {
+    let parsed;
+    try {
+      parsed = parseTranscript(client, source);
+    } catch {
+      logger.debug(`Failed to parse ${source}, skipping.`);
+      continue;
+    }
+    if (!transcriptHasContent(parsed)) continue;
+    if (!transcriptMatchesRepo(parsed, projectPath, repoSlug)) continue;
+    scanSensitive(parsed, projectPath);
+    try {
+      await importTranscript(parsed, projectPath, globalRoot, repoSlug, "not-set", true);
+      importedCount++;
+    } catch {
+      logger.exception(`Failed to import transcript: ${source}`);
+    }
+  }
+  if (importedCount === 0) {
+    logger.info(`[${projectName}] No new transcripts to import.`);
+    return;
+  }
+  logger.info(`[${projectName}] Imported ${importedCount} transcript(s).`);
+  gitCommitAndPush(config, projectPath, projectName, importedCount);
+}
+function scanSensitive(parsed, projectPath) {
+  const logger = getLogger();
+  for (const msg of parsed.messages) {
+    for (const pattern of SENSITIVE_PATTERNS) {
+      if (pattern.test(msg.text)) {
+        logger.warn(
+          `Sensitive pattern detected in transcript ${parsed.source_path} (project: ${projectPath.split(/[/\\]/).pop() ?? ""}, role: ${msg.role})`
+        );
+        writeAlert(
+          toPosixPath2(projectPath),
+          "sensitive_match",
+          `Sensitive pattern in transcript: ${parsed.source_path.split(/[/\\]/).pop() ?? ""}`
+        );
+        return;
+      }
+    }
+  }
+}
+function gitCommitAndPush(config, projectPath, projectName, count) {
+  const logger = getLogger();
+  const status = git(projectPath, "status", "--porcelain", "Memory/");
+  if (!status.trim()) {
+    logger.info(`[${projectName}] No git changes in Memory/.`);
+    return;
+  }
+  git(projectPath, "add", "Memory/");
+  git(projectPath, "commit", "-m", `memorytree(transcripts): import ${count} transcript(s)`);
+  logger.info(`[${projectName}] Committed ${count} transcript import(s).`);
+  if (!config.auto_push) {
+    logger.info(`[${projectName}] auto_push disabled, skipping push.`);
+    return;
+  }
+  const remotes = git(projectPath, "remote");
+  if (!remotes.trim()) {
+    logger.warn(`[${projectName}] No git remote configured, skipping push.`);
+    writeAlert(toPosixPath2(projectPath), "no_remote", "Push skipped: no Git remote configured.");
+    return;
+  }
+  if (!tryPush(projectPath, projectName)) {
+    logger.warn(`[${projectName}] Push failed, retrying once...`);
+    if (!tryPush(projectPath, projectName)) {
+      logger.error(`[${projectName}] Push failed after retry.`);
+      writeAlertWithThreshold(toPosixPath2(projectPath), "push_failed", "Push failed after retry.");
+      return;
+    }
+  }
+  resetFailureCount(toPosixPath2(projectPath), "push_failed");
+}
+function tryPush(projectPath, projectName) {
+  try {
+    git(projectPath, "push");
+    getLogger().info(`[${projectName}] Pushed successfully.`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export {
+  ALERT_TYPES,
+  FAILURE_THRESHOLD,
+  MAX_ALERTS,
+  _resetLogger,
+  acquireLock,
+  alertsPath,
+  clearAlerts,
+  configPath,
+  formatAlertsForDisplay,
+  getLogger,
+  gitCommitAndPush,
+  main as heartbeatMain,
+  intervalToSeconds,
+  isProcessAlive,
+  loadConfig,
+  lockPath,
+  memorytreeRoot,
+  processProject,
+  readAlerts,
+  readLockPid,
+  registerProject,
+  releaseLock,
+  resetFailureCount,
+  runHeartbeat,
+  saveConfig,
+  scanSensitive,
+  setupLogging,
+  tryPush,
+  writeAlert,
+  writeAlertWithThreshold
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@openmnemo/sync",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Heartbeat daemon, config management, and background sync for OpenMnemo",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openmnemo/openmnemo.git",
+    "directory": "packages/sync"
+  },
+  "homepage": "https://github.com/openmnemo/openmnemo#readme",
+  "author": "OpenMnemo Contributors",
+  "license": "MIT",
+  "keywords": [
+    "openmnemo",
+    "memory",
+    "sync",
+    "heartbeat",
+    "daemon"
+  ],
+  "dependencies": {
+    "smol-toml": "^1.3.1",
+    "@openmnemo/core": "0.1.0",
+    "@openmnemo/types": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.3",
+    "vitest": "^3.1.1"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "test": "vitest run",
+    "lint": "eslint src tests",
+    "typecheck": "tsc --noEmit"
+  }
+}