luckytri 1.0.0

package/server/mind/anticipations.js

@@ -0,0 +1,507 @@
+import { randomUUID } from "node:crypto";
+import { localClock } from "../core/conversation-cues.js";
+import { hasCredential } from "./guard.js";
+import { isPrivateSession } from "./memory.js";
+import { lifeSpan } from "./nature.js";
+import { classifyActivity, isExecutable } from "./time/tasks.js";
+import { taskIntent } from "./time/intent.js";
+import { DAY, evidence, parse, similar, text, zonedTime } from "./util.js";
+
+// What she is looking ahead to: promises she made, things she means to do,
+// what others told her is coming, and the dates that come back every year.
+export const ANTICIPATION_KINDS = {
+  promise: "答应的事",
+  plan: "想做的事",
+  event: "别人的安排",
+  date: "每年的日子",
+};
+// How long after its day something still waits to be asked about or done
+// before it quietly counts as missed.
+const GRACE = { event: 3 * DAY, promise: 7 * DAY, plan: 7 * DAY, date: 0 };
+const HORIZON = 400 * DAY;
+const CLOSE = new Set(["done", "missed", "let_go"]);
+
+function row(value) {
+  return value
+    ? {
+        ...value,
+        sources: parse(value.sources, []),
+        closed_sources: parse(value.closed_sources, []),
+      }
+    : null;
+}
+
+export class Anticipations {
+  constructor(mind) {
+    this.mind = mind;
+    this.db = mind.db;
+  }
+  day(time) {
+    return localClock(time, this.mind.timeZone()).local.slice(0, 10);
+  }
+  // A yearly date's next return (or today's), otherwise the one due moment.
+  occurrence(a, now) {
+    if (a.recurrence !== "yearly") return a.due_at;
+    const monthDay = this.day(a.due_at).slice(5);
+    const year = Number(this.day(now).slice(0, 4));
+    for (const y of [year - 1, year, year + 1]) {
+      const at = zonedTime(`${y}-${monthDay}`, this.mind.timeZone());
+      if (at !== null && at + DAY > now) return at;
+    }
+    return a.due_at;
+  }
+  ends(a, due) {
+    return due + (a.due_precision === "time" ? 0 : DAY);
+  }
+  // From the start of the day before.
+  opens(due) {
+    const midnight = zonedTime(this.day(due), this.mind.timeZone());
+    return (midnight ?? due) - DAY;
+  }
+  // Her name for someone, or the name they last used where it was said.
+  who(a) {
+    if (!a.subject) return "";
+    const known = this.mind.bonds.name(a.subject);
+    if (known) return known;
+    const said = parse(
+      this.db
+        .prepare(
+          "SELECT payload FROM core_events WHERE session_id=? AND role='user' AND json_extract(payload,'$.userId')=? ORDER BY seq DESC LIMIT 1",
+        )
+        .get(a.session_id, String(a.subject))?.payload,
+      {},
+    );
+    return said.name || a.subject;
+  }
+  lapsed(a, now) {
+    return (
+      a.recurrence !== "yearly" &&
+      now > this.ends(a, a.due_at) + (GRACE[a.kind] ?? GRACE.event)
+    );
+  }
+  // A private promise can be written in her diary. It cannot be carried out
+  // of that room, or into the story she retells everywhere.
+  concealed(a) {
+    return a.discretion !== "open" || isPrivateSession(a.session_id);
+  }
+  // Private rooms whose plans, promises, or dates the diary of `day` would see.
+  privateRooms(day, before = Date.now()) {
+    const nature = this.mind.nature.current(before);
+    const zone = this.mind.timeZone();
+    const span = lifeSpan(nature, day, zone);
+    if (!span || span.start > before) return [];
+    const end = Math.min(before, span.end);
+    const rooms = new Set();
+    for (const a of this.db
+      .prepare(
+        "SELECT * FROM mind_anticipations WHERE created<=? AND status!='revoked'",
+      )
+      .all(before)
+      .map(row)) {
+      if (!this.concealed(a) || !this.#onDay(a, span, end)) continue;
+      // The room where it was said may still see that day's diary. A marker
+      // with no room would hide the diary everywhere, including there.
+      rooms.add(a.session_id || `a:${a.id}`);
+    }
+    return [...rooms];
+  }
+  #onDay(a, span, before) {
+    const pending =
+      a.status === "pending" || (a.closed_at != null && a.closed_at > before);
+    if (
+      !pending &&
+      a.closed_at >= span.start &&
+      a.closed_at < span.end &&
+      a.closed_at <= before
+    )
+      return true;
+    if (a.recurrence === "yearly")
+      return this.day(this.occurrence(a, span.start)) === this.day(span.start);
+    if (a.due_at >= span.start && a.due_at < span.end) return true;
+    const lapse = this.ends(a, a.due_at) + (GRACE[a.kind] ?? GRACE.event);
+    return pending && lapse >= span.start && lapse < span.end;
+  }
+  revokedContents() {
+    return this.db
+      .prepare(
+        "SELECT content FROM mind_revocations WHERE target_kind='anticipation'",
+      )
+      .all()
+      .map((r) => r.content)
+      .filter(Boolean);
+  }
+  add({
+    kind,
+    subject = null,
+    session = null,
+    content,
+    due,
+    recurrence = "none",
+    discretion = "open",
+    sources = [],
+    origin = "memory",
+    activity = "",
+    time = Date.now(),
+  }) {
+    if (!ANTICIPATION_KINDS[kind]) return { rejected: "类型无效" };
+    const words = text(content, 120);
+    if (!words || hasCredential(words)) return { rejected: "内容无效" };
+    const refs = evidence(sources);
+    if (!refs.length) return { rejected: "缺少来源" };
+    const when = String(due ?? "").trim();
+    const at = zonedTime(when, this.mind.timeZone());
+    if (at === null) return { rejected: "日期无效" };
+    const yearly = kind === "date" || recurrence === "yearly";
+    const precision = /\d{2}:\d{2}$/.test(when) ? "time" : "day";
+    if (
+      !yearly &&
+      (this.ends({ due_precision: precision }, at) <= time - DAY ||
+        at > time + HORIZON)
+    )
+      return { rejected: "日期不在合理范围" };
+    const who = subject ? String(subject) : "";
+    if (
+      this.revokedContents().some((old) =>
+        similar(old, `${who}\n${words}`, 0.75),
+      )
+    )
+      return { rejected: "与撤销过的内容相同" };
+    if (!yearly && ["plan", "promise"].includes(kind)) {
+      const input = {
+          title: words,
+          activity: activity || classifyActivity(words),
+          subject,
+          session,
+          sources: refs,
+        },
+        intent = taskIntent(this.db, input);
+      if (intent.key) {
+        const tracked = this.mind.time?.tasks.links.find(input);
+        const prior = tracked
+          ? this.mind.time.tasks.links
+              .anticipations(tracked)
+              .map((id) => this.get(id))
+              .find((a) => a && a.status !== "revoked")
+          : this.db
+              .prepare(
+                "SELECT * FROM mind_anticipations WHERE kind IN ('plan','promise') AND status='pending' ORDER BY created",
+              )
+              .all()
+              .find(
+                (a) =>
+                  taskIntent(this.db, {
+                    title: a.content,
+                    activity: a.activity || classifyActivity(a.content),
+                    subject: a.subject,
+                    session: a.session_id,
+                    sources: parse(a.sources, []),
+                  }).key === intent.key,
+              );
+        if (tracked || prior) {
+          if (tracked) {
+            this.mind.time.tasks.links.mergeSource(
+              tracked,
+              {
+                sources: refs,
+                kind,
+                subject: who || intent.recipient,
+                dueAt: at,
+                duePrecision: precision,
+                origin,
+              },
+              time,
+            );
+            if (tracked.state === "abandoned")
+              this.mind.time.tasks.links.close(
+                tracked,
+                "原事项已放下，重复整理不能恢复",
+                time,
+              );
+          } else
+            this.db
+              .prepare("UPDATE mind_anticipations SET sources=? WHERE id=?")
+              .run(
+                JSON.stringify(
+                  evidence([...parse(prior.sources, []), ...refs]),
+                ),
+                prior.id,
+              );
+          return {
+            duplicate: prior?.id || tracked.id,
+            task: tracked?.id,
+            suppressed: tracked?.state === "abandoned",
+          };
+        }
+      }
+    }
+    const key = yearly ? this.day(at).slice(5) : this.day(at);
+    const same = this.db
+      .prepare(
+        "SELECT * FROM mind_anticipations WHERE status='pending' AND COALESCE(subject,'')=? AND kind=?",
+      )
+      .all(who, kind)
+      .find(
+        (r) =>
+          (yearly ? this.day(r.due_at).slice(5) : this.day(r.due_at)) === key &&
+          similar(r.content, words, 0.6),
+      );
+    if (same) return { duplicate: same.id };
+    const id = randomUUID();
+    this.db
+      .prepare(
+        "INSERT INTO mind_anticipations(id,created,kind,subject,session_id,content,due_at,due_precision,recurrence,discretion,sources,origin,activity) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)",
+      )
+      .run(
+        id,
+        time,
+        kind,
+        who || null,
+        session,
+        words,
+        at,
+        precision,
+        yearly ? "yearly" : "none",
+        ["open", "private", "secret"].includes(discretion)
+          ? discretion
+          : "open",
+        JSON.stringify(refs),
+        origin,
+        kind === "plan" && isExecutable(activity) ? activity : "",
+      );
+    return { id };
+  }
+  get(id) {
+    return row(
+      this.db.prepare("SELECT * FROM mind_anticipations WHERE id=?").get(id),
+    );
+  }
+  // Still open at `now`; something closed later still counts when looking back.
+  pending(now = Date.now()) {
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_anticipations WHERE created<=? AND (status='pending' OR (closed_at IS NOT NULL AND closed_at>? AND status!='revoked')) ORDER BY due_at",
+      )
+      .all(now, now)
+      .map(row);
+  }
+  close(id, { status, note = "", sources = [], time = Date.now() } = {}) {
+    if (!CLOSE.has(status)) return false;
+    const a = this.get(id);
+    if (!a || a.status !== "pending" || a.recurrence === "yearly") return false;
+    if (status === "done") {
+      if (
+        ["plan", "promise"].includes(a.kind) &&
+        (a.activity || classifyActivity(a.content) !== "unknown")
+      )
+        this.mind.time?.tasks.sync(time);
+      const task = this.db
+        .prepare(
+          "SELECT state,share_state FROM mind_time_tasks WHERE anticipation_id=?",
+        )
+        .get(id);
+      if (
+        task &&
+        (task.state !== "done" || !["none", "sent"].includes(task.share_state))
+      )
+        return false;
+    }
+    return (
+      this.db
+        .prepare(
+          "UPDATE mind_anticipations SET status=?,closed_at=?,closed_note=?,closed_sources=? WHERE id=? AND status='pending'",
+        )
+        .run(
+          status,
+          time,
+          text(note, 120),
+          JSON.stringify(evidence(sources)),
+          id,
+        ).changes > 0
+    );
+  }
+  revoke(id, reason = "") {
+    const a = this.get(id);
+    if (!a) throw Error("约定不存在");
+    this.db
+      .prepare(
+        "UPDATE mind_anticipations SET status='revoked',closed_at=?,closed_note=? WHERE id=?",
+      )
+      .run(Date.now(), text(reason, 120), id);
+    return `${a.subject || ""}\n${a.content}`;
+  }
+  relative(due, now, precision = "day") {
+    const zone = this.mind.timeZone();
+    const at = (t) =>
+      Date.parse(`${localClock(t, zone).local.slice(0, 10)}T00:00:00Z`);
+    const days = Math.round((at(due) - at(now)) / DAY);
+    const clock =
+      precision === "time" ? ` ${localClock(due, zone).local.slice(11)}` : "";
+    const named = {
+      0: "今天",
+      1: "明天",
+      2: "后天",
+      [-1]: "昨天",
+      [-2]: "前天",
+    };
+    if (named[days] !== undefined) return named[days] + clock;
+    return days > 0 ? `${days} 天后` : `${-days} 天前`;
+  }
+  label(a, due, now) {
+    const who = this.who(a);
+    const when = this.relative(due, now, a.due_precision);
+    if (a.kind === "promise") {
+      const task = this.db
+        .prepare(
+          "SELECT state,share_state,checkpoint FROM mind_time_tasks WHERE anticipation_id=?",
+        )
+        .get(a.id);
+      const progress =
+        task?.state === "done" && task.share_state !== "sent"
+          ? "作品完成，尚未交付"
+          : task?.state === "doing"
+            ? "正在做"
+            : parse(task?.checkpoint, {}).workId
+              ? "已有草稿，尚未完成"
+              : "还没做";
+      return `我答应${who ? `${who}` : ""}：${a.content}（${when}${a.status === "pending" ? "，" + progress : ""}）`;
+    }
+    if (a.kind === "plan") return `我打算：${a.content}（${when}）`;
+    if (a.kind === "event")
+      return `${who ? `${who}计划：` : "有人计划："}${a.content}（${when}，结果未确认）`;
+    return `${who ? `${who}：` : ""}${a.content}（${when}）`;
+  }
+  // Near enough to matter in a conversation: from the day before until a few
+  // days after, and only where it belongs.
+  upcoming({ now = Date.now(), people = [], session = "", limit = 3 } = {}) {
+    const here = new Set(session ? this.mind.memory.scopes(session) : []);
+    const present = new Set(people.map(String));
+    const out = [];
+    for (const a of this.pending(now)) {
+      const due = this.occurrence(a, now);
+      const after =
+        a.recurrence === "yearly" ? 0 : (GRACE[a.kind] ?? GRACE.event);
+      if (now < this.opens(due) || now >= this.ends(a, due) + after) continue;
+      // A plan by someone else in this room belongs to that person. Its
+      // presence in the same group must not make it A's plan when B said it.
+      const relevant = a.subject
+        ? present.has(String(a.subject))
+        : a.session_id === session || a.kind === "plan";
+      if (!relevant) continue;
+      const local = here.has(a.session_id);
+      if (a.discretion !== "open" && !local) continue;
+      out.push({ id: a.id, due, text: this.label(a, due, now) });
+      if (out.length >= limit) break;
+    }
+    return out;
+  }
+  // What she might think about when alone: due soon, just past, or quietly
+  // missed within the last week.
+  // What is still ahead comes first, soonest first. Then what was due but still
+  // waits (inside its grace), then what already lapsed; both the most recent
+  // first, so a week-old plan of someone else does not take the places from
+  // what is near now.
+  due({ now = Date.now(), limit = 5, shareable = false } = {}) {
+    const found = [];
+    for (const a of this.pending(now)) {
+      if (shareable && this.concealed(a)) continue;
+      const due = this.occurrence(a, now);
+      const after =
+        a.recurrence === "yearly"
+          ? 0
+          : (GRACE[a.kind] ?? GRACE.event) + 7 * DAY;
+      if (now < this.opens(due) || now >= this.ends(a, due) + after) continue;
+      const lapsed = this.lapsed(a, now);
+      // 0: its day has not passed yet; 1: due, still inside the grace;
+      // 2: already lapsed.
+      const rank = lapsed ? 2 : this.ends(a, due) <= now ? 1 : 0;
+      found.push({
+        due,
+        rank,
+        item: {
+          ref: `a:${a.id}`,
+          kind: ANTICIPATION_KINDS[a.kind],
+          ...(a.subject ? { who: this.who(a), userId: a.subject } : {}),
+          content: a.content,
+          when: this.relative(due, now, a.due_precision),
+          ...(lapsed ? { lapsed: true } : {}),
+          ...(a.recurrence === "yearly" ? { yearly: true } : {}),
+        },
+      });
+    }
+    return found
+      .sort(
+        (a, b) => a.rank - b.rank || (a.rank ? b.due - a.due : a.due - b.due),
+      )
+      .slice(0, limit)
+      .map((entry) => entry.item);
+  }
+  // Something she was looking ahead to has come close, or just passed.
+  newlyDue(since, now = Date.now()) {
+    return this.pending(now).some((a) => {
+      const due = this.occurrence(a, now);
+      const edges = [this.opens(due), this.ends(a, due)];
+      return edges.some((edge) => edge > since && edge <= now);
+    });
+  }
+  // The day's promises kept and missed, and the dates that fall on it.
+  today({ start, end, shareable = false }) {
+    const keep = (a) => !shareable || !this.concealed(a);
+    const closed = this.db
+      .prepare(
+        "SELECT * FROM mind_anticipations WHERE closed_at>=? AND closed_at<? AND status IN ('done','missed','let_go') ORDER BY closed_at",
+      )
+      .all(start, end)
+      .map(row)
+      .filter(keep);
+    const lapsedToday = this.pending(end).filter((a) => {
+      if (!keep(a) || a.recurrence === "yearly") return false;
+      const at = this.ends(a, a.due_at) + (GRACE[a.kind] ?? GRACE.event);
+      return at >= start && at < end;
+    });
+    const line = (a) => this.label(a, this.occurrence(a, start), start);
+    const byStatus = (status) =>
+      closed.filter((a) => a.status === status).map(line);
+    return {
+      kept: byStatus("done"),
+      missed: [...byStatus("missed"), ...lapsedToday.map(line)],
+      letGo: byStatus("let_go"),
+      dates: this.pending(end)
+        .filter(
+          (a) =>
+            keep(a) &&
+            a.recurrence === "yearly" &&
+            this.day(this.occurrence(a, start)) === this.day(start),
+        )
+        .map(line),
+      dueToday: this.pending(end)
+        .filter(
+          (a) =>
+            keep(a) &&
+            a.recurrence !== "yearly" &&
+            a.due_at >= start &&
+            a.due_at < end,
+        )
+        .map(line),
+    };
+  }
+  list({ now = Date.now(), limit = 100 } = {}) {
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_anticipations ORDER BY CASE status WHEN 'pending' THEN 0 ELSE 1 END, due_at LIMIT ?",
+      )
+      .all(limit)
+      .map(row)
+      .map((a) => {
+        const due = this.occurrence(a, now);
+        return {
+          ...a,
+          name: this.who(a),
+          occurrence: due,
+          when: this.relative(due, now, a.due_precision),
+          state:
+            a.status === "pending" && this.lapsed(a, now) ? "lapsed" : a.status,
+          private: a.discretion !== "open" || isPrivateSession(a.session_id),
+        };
+      });
+  }
+}