refactor: consolidate agent/editor plugins under integrations/ (#5491)

Co-authored-by: Claude <noreply@anthropic.com>

integrations/pi-agent-plugin/src/dream/index.ts

@@ -0,0 +1,115 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { DreamState, DreamLock, DreamConfig } from "../types.ts";
+
+const LOCK_STALE_MS = 60 * 60 * 1000;
+
+const DEFAULTS: DreamConfig = {
+  enabled: true,
+  auto: true,
+  minHours: 24,
+  minSessions: 5,
+  minMemories: 20,
+};
+
+function statePath(stateDir: string): string {
+  return path.join(stateDir, "mem0-dream-state.json");
+}
+
+function lockPath(stateDir: string): string {
+  return path.join(stateDir, "mem0-dream.lock");
+}
+
+function ensureDir(dir: string): void {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch { /* exists */ }
+}
+
+function readState(stateDir: string): DreamState {
+  try {
+    const raw = fs.readFileSync(statePath(stateDir), "utf-8");
+    return JSON.parse(raw) as DreamState;
+  } catch {
+    return { lastConsolidatedAt: 0, sessionsSince: 0, lastSessionId: null };
+  }
+}
+
+function writeState(stateDir: string, state: DreamState): void {
+  ensureDir(stateDir);
+  fs.writeFileSync(statePath(stateDir), JSON.stringify(state, null, 2));
+}
+
+export function incrementSessionCount(stateDir: string, sessionId: string): void {
+  const state = readState(stateDir);
+  if (state.lastSessionId !== sessionId) {
+    state.sessionsSince++;
+    state.lastSessionId = sessionId;
+    writeState(stateDir, state);
+  }
+}
+
+export function checkCheapGates(
+  stateDir: string,
+  config: Partial<DreamConfig>,
+): { proceed: boolean; reason?: string } {
+  const minHours = config.minHours ?? DEFAULTS.minHours;
+  const minSessions = config.minSessions ?? DEFAULTS.minSessions;
+  const state = readState(stateDir);
+
+  const hoursSince = (Date.now() - state.lastConsolidatedAt) / 3_600_000;
+  if (hoursSince < minHours) {
+    return { proceed: false, reason: `time: ${hoursSince.toFixed(1)}h < ${minHours}h` };
+  }
+
+  if (state.sessionsSince < minSessions) {
+    return { proceed: false, reason: `sessions: ${state.sessionsSince} < ${minSessions}` };
+  }
+
+  return { proceed: true };
+}
+
+export function checkMemoryGate(
+  memoryCount: number,
+  config: Partial<DreamConfig>,
+): { pass: boolean; reason?: string } {
+  const minMemories = config.minMemories ?? DEFAULTS.minMemories;
+  if (memoryCount < minMemories) {
+    return { pass: false, reason: `memories: ${memoryCount} < ${minMemories}` };
+  }
+  return { pass: true };
+}
+
+export function acquireDreamLock(stateDir: string): boolean {
+  ensureDir(stateDir);
+  const lp = lockPath(stateDir);
+
+  try {
+    const raw = fs.readFileSync(lp, "utf-8");
+    const lock = JSON.parse(raw) as DreamLock;
+    if (Date.now() - lock.startedAt < LOCK_STALE_MS) {
+      return false;
+    }
+    try { fs.unlinkSync(lp); } catch { /* race ok */ }
+  } catch { /* no lock file */ }
+
+  const lock: DreamLock = { pid: process.pid, startedAt: Date.now() };
+  try {
+    fs.writeFileSync(lp, JSON.stringify(lock), { flag: "wx" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function releaseDreamLock(stateDir: string): void {
+  try { fs.unlinkSync(lockPath(stateDir)); } catch { /* already gone */ }
+}
+
+export function recordDreamCompletion(stateDir: string): void {
+  const state = readState(stateDir);
+  state.lastConsolidatedAt = Date.now();
+  state.sessionsSince = 0;
+  state.lastSessionId = null;
+  writeState(stateDir, state);
+}