@modusensus/dsh-mneme 0.7.9 → 0.7.11

package/dsh-mneme/src/dream/tag-extractor.js

@@ -1,156 +0,0 @@
-// v0.6.2 auto-tag: a lightweight LLM pass that runs after an autoDream
-// consolidation and extracts 1-3 tags per retained memory. Opt-in via
-// config.autoTagEnabled (default false); autoTagMaxPerRun (default 10) bounds
-// how many memories are tagged per run.
-//
-// Design notes:
-//   - ONE batched LLM call per run (the consolidation route is reused). Each
-//     memory is a prompt line; the model replies with a JSON array of
-//     {"id","tags"} entries — the per-memory contract is `{"tags":[...]}`.
-//   - Fail-safe everywhere: a missing route / aborted stream / unparseable
-//     JSON / unknown id / illegal tag are all skipped, never thrown. Tagging
-//     must never degrade the consolidation run it rides on.
-//   - The actual writes go through service.applyMemoryTags inside a
-//     service.transaction, so the mirror re-renders exactly once per pass and
-//     the write hooks fire once (never per memory).
-import { sanitizeTags, MAX_TAG_LENGTH } from "../parser/tag.js";
-
-const TAG_PROMPT = `你是记忆库标签助手。下面是保留的记忆条目（id、标题、内容）。
-对每条记忆提取 1-3 个中文或英文标签，用于检索分类。
-标签规则：
-- 只允许字符：字母、数字、下划线、中文、连字符（如：linux、考研、deepseek-r1）
-- 标签长度 ≤ ${MAX_TAG_LENGTH} 字符
-- 宁缺毋滥：提取最核心的 1-3 个，不要凑数
-- 不要输出内容里没有依据的标签
-只输出一个 JSON 数组，每项形如 { "id": "<记忆id>", "tags": ["标签1", "标签2"] }。
-不要输出其他文字。`;
-
-/** Same stream consumption contract as dream.js. Returns accumulated text or
- *  undefined when the stream aborted/errored. */
-async function streamText(ctx, options) {
-  if (!ctx?.llm?.stream) return undefined;
-  let text = "";
-  for await (const chunk of ctx.llm.stream(options)) {
-    if (chunk.type === "text-delta" && typeof chunk.text === "string") text += chunk.text;
-    if (chunk.type === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) {
-      return undefined;
-    }
-  }
-  return text;
-}
-
-/** Pull the outermost JSON array out of a model reply (same tolerant contract
- *  as sleep.js parseJsonArray): find the first `[` … last `]` and parse. */
-function parseJsonArray(text) {
-  if (typeof text !== "string") return undefined;
-  const start = text.indexOf("[");
-  const end = text.lastIndexOf("]");
-  if (start === -1 || end <= start) return undefined;
-  try {
-    const parsed = JSON.parse(text.slice(start, end + 1));
-    return Array.isArray(parsed) ? parsed : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-/** Resolve the LLM route for the tag pass: the caller-provided consolidation
- *  route first, then dreamProvider/dreamModel. Falls through to undefined. */
-function resolveTagRoute(route, config, logger) {
-  if (route?.provider && route?.model) return route;
-  if (config?.dreamProvider && config?.dreamModel) return { provider: config.dreamProvider, model: config.dreamModel };
-  logger?.warn?.("dsh-mneme auto-tag: no llm route available");
-  return undefined;
-}
-
-/**
- * Run the auto-tag pass over retained memories.
- * @param {object} opts
- * @param {object} opts.ctx        — { llm, logger }
- * @param {object} opts.service    — service handle (all/transaction/applyMemoryTags)
- * @param {object} opts.config     — plugin config (autoTagMaxPerRun, dreamProvider…)
- * @param {object} [opts.route]    — already-resolved consolidation route
- * @returns {Promise<{ok: boolean, tagged: number, skipped: number, failed: number, skippedBy: boolean}>}
- */
-export async function runAutoTag({ ctx, service, config, route }) {
-  const logger = ctx?.logger;
-  const maxPerRun = Number.isInteger(config?.autoTagMaxPerRun) && config.autoTagMaxPerRun > 0
-    ? config.autoTagMaxPerRun
-    : 10;
-  // Retained = post-consolidation active memories, newest first, capped.
-  // Skip memories that already carry live tags — otherwise every run re-picks
-  // the same "newest" batch (tagging doesn't bump updated_at) and older
-  // memories starve; manual tags are also left untouched this way.
-  const memories = service.all()
-    .filter((m) => !m.forgotten && !m.archived && !m.session_disposed_at && m.type !== "summary")
-    .filter((m) => (service.getMemoryTags?.(m.id) ?? []).length === 0)
-    .sort((a, b) => {
-      const ta = String(a.updated_at ?? "");
-      const tb = String(b.updated_at ?? "");
-      if (ta < tb) return 1;
-      if (ta > tb) return -1;
-      return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
-    })
-    .slice(0, Math.max(1, maxPerRun));
-  if (!memories.length) return { ok: true, tagged: 0, skipped: 0, failed: 0, skippedBy: "empty" };
-  const tagRoute = resolveTagRoute(route, config, logger);
-  if (!tagRoute) return { ok: false, tagged: 0, skipped: memories.length, failed: 0, skippedBy: "no-route" };
-
-  const listText = memories
-    .map((m) => `id=${m.id} | title=${m.title} | content=${m.content}`)
-    .join("\n");
-  const text = await streamText(ctx, {
-    provider: tagRoute.provider,
-    model: tagRoute.model,
-    purpose: "compaction",
-    maxTokens: Math.min(2048, config?.dreamMaxTokens ?? 2048),
-    messages: [
-      { role: "system", content: [{ type: "text", text: TAG_PROMPT }] },
-      { role: "user", content: [{ type: "text", text: listText }] }
-    ]
-  });
-  if (text === undefined) return { ok: false, tagged: 0, skipped: memories.length, failed: 0, skippedBy: "llm-failed" };
-
-  const entries = parseJsonArray(text);
-  if (!entries) {
-    logger?.warn?.("dsh-mneme auto-tag: no json array in llm output");
-    return { ok: false, tagged: 0, skipped: memories.length, failed: 0, skippedBy: "bad-json" };
-  }
-
-  // Validate ids against the candidate set (unknown ids are ignored, never
-  // written — a stray id could otherwise tag an unrelated memory).
-  const candidateIds = new Set(memories.map((m) => m.id));
-  const toWrite = [];
-  let skipped = 0;
-  let failed = 0;
-  const seenIds = new Set();
-  for (const entry of entries) {
-    if (!entry || typeof entry !== "object") { failed++; continue; }
-    const id = typeof entry.id === "string" ? entry.id : undefined;
-    if (!id || !candidateIds.has(id)) { failed++; continue; }
-    if (seenIds.has(id)) continue; // first entry per id wins
-    seenIds.add(id);
-    // Reuse the shared sanitizer: strip, ≤20 chars, drop illegal, dedupe.
-    const tags = sanitizeTags(entry.tags);
-    if (!tags.length) { skipped++; continue; }
-    toWrite.push({ id, tags });
-  }
-
-  // Write the whole batch under one transaction: mirror re-renders once.
-  let tagged = 0;
-  try {
-    service.transaction(() => {
-      for (const { id, tags } of toWrite) {
-        // Merge with existing live tags (never clobber manual tags that landed
-        // between selection and write).
-        const existing = service.getMemoryTags?.(id) ?? [];
-        service.applyMemoryTags(id, [...new Set([...existing, ...tags])]);
-        tagged++;
-      }
-    });
-  } catch (error) {
-    logger?.warn?.(`dsh-mneme auto-tag: write failed: ${String(error)}`);
-    return { ok: false, tagged, skipped, failed, skippedBy: "write-failed" };
-  }
-  return { ok: true, tagged, skipped, failed, skippedBy: false };
-}

package/dsh-mneme/src/heat.js

@@ -1,136 +0,0 @@
-// dsh-mneme/src/heat.js
-// 热度（heat）纯函数模块：基于类遗忘曲线计算 memory 的当前热度。
-// 零数据库依赖，不引入任何外部依赖。
-
-/**
- * 默认的 per-type 衰减因子 λ。
- * λ = 0 表示该类型免疫热度衰减，热度恒为 1.0。
- */
-export const TYPE_DECAY_DEFAULTS = Object.freeze({
-  preference: 0,    // 免疫：用户画像需长期保持
-  pattern: 0,       // 免疫：发现型稳定规律
-  summary: 0,       // 免疫：已是压缩产物
-  project: 0.0008,  // 慢衰减
-  decision: 0.002,  // 中速衰减
-  history: 0.006,   // 较快（会话摘要不断被合并）
-});
-
-const HOUR_MS = 3600000;
-const DEFAULT_ALPHA = 1.2;
-const DEFAULT_LAMBDA = 0.002;
-
-/**
- * 将可能的日期值统一转成毫秒时间戳。
- * 支持 Date、number、ISO 字符串；无法解析时返回 NaN。
- */
-function toTimestamp(value) {
-  if (value === null || value === undefined) return NaN;
-
-  if (value instanceof Date) {
-    return Number.isFinite(value.getTime()) ? value.getTime() : NaN;
-  }
-
-  if (typeof value === 'number') {
-    return Number.isFinite(value) ? value : NaN;
-  }
-
-  if (typeof value === 'string') {
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : NaN;
-  }
-
-  return NaN;
-}
-
-/**
- * 获取用于计算热度的参考时间点 ref。
- * 优先取 last_accessed_at；缺失时退到 created_at。
- * 绝不 fallback 到 updated_at。
- */
-function getRef(memory) {
-  if (!memory || typeof memory !== 'object') return NaN;
-  return toTimestamp(memory.last_accessed_at ?? memory.created_at);
-}
-
-/**
- * 解析并校验配置，提供安全的 alpha 与衰减表。
- */
-function resolveConfig(config) {
-  const safe = config && typeof config === 'object' ? config : {};
-
-  let alpha = safe.heatGlobalAlpha ?? DEFAULT_ALPHA;
-  if (!Number.isFinite(alpha) || alpha <= 0) {
-    alpha = DEFAULT_ALPHA;
-  }
-
-  const decayMap = safe.heatTypeDecay ?? TYPE_DECAY_DEFAULTS;
-
-  return { alpha, decayMap };
-}
-
-/**
- * 构建热度信号对象，便于调试与后续扩展。
- *
- * @param {object} memory - memory 记录
- * @param {object} config - 插件配置
- * @param {number} [now=Date.now()] - 当前毫秒时间戳
- * @returns {{ type, ref, lambda, alpha, deltaHours }}
- */
-export function buildHeatSignals(memory, config, now = Date.now()) {
-  const nowMs = Number.isFinite(now) ? now : Date.now();
-  const ref = getRef(memory);
-  const { alpha, decayMap } = resolveConfig(config);
-
-  const type = memory?.type;
-
-  // 取对应类型的 λ，未知类型走默认
-  let lambda = decayMap[type];
-  if (!Number.isFinite(lambda)) {
-    lambda = DEFAULT_LAMBDA;
-  }
-  // λ < 0 视为非法，回退到默认；λ === 0 保留为免疫
-  if (lambda < 0) {
-    lambda = DEFAULT_LAMBDA;
-  }
-
-  let deltaHours;
-  if (!Number.isFinite(ref)) {
-    deltaHours = NaN;
-  } else if (nowMs < ref) {
-    deltaHours = 0;
-  } else {
-    deltaHours = (nowMs - ref) / HOUR_MS;
-  }
-
-  return { type, ref, lambda, alpha, deltaHours };
-}
-
-/**
- * 计算 memory 的热度 H ∈ [0, 1]。
- *
- * 公式：H = 1 / (1 + λ · ΔtHours)^α
- *
- * @param {object} memory - memory 记录
- * @param {number} [now=Date.now()] - 当前毫秒时间戳
- * @param {object} [config={}] - 插件配置
- * @returns {number} 热度值
- */
-export function computeHeat(memory, now = Date.now(), config = {}) {
-  const signals = buildHeatSignals(memory, config, now);
-  const { alpha, lambda, deltaHours, ref } = signals;
-
-  // 无有效参考时间、或未来时间，热度视为满格
-  if (!Number.isFinite(ref) || deltaHours <= 0) {
-    return 1.0;
-  }
-
-  // λ = 0 的类型免疫，热度恒满
-  if (lambda === 0) {
-    return 1.0;
-  }
-
-  const heat = 1 / Math.pow(1 + lambda * deltaHours, alpha);
-
-  // 防止浮点误差越界
-  return Math.min(1, Math.max(0, heat));
-}

package/dsh-mneme/src/parser/tag.js

@@ -1,59 +0,0 @@
-/**
- * Tag parser (v0.6.2). Given a memory's content, extract explicit hashtags of
- * the form `#标签`. The allowed character set is `[a-zA-Z0-9_一-龥-]+` (ASCII
- * letters/digits/underscore, CJK characters, and hyphen), so `#linux`,
- * `#deepseek` and `#考研` are all valid tags.
- *
- * Rules:
- *   - multiple tags on one line are all extracted, in source order;
- *   - duplicates collapse to the first occurrence;
- *   - tags longer than MAX_TAG_LENGTH (20) characters are dropped as illegal;
- *   - edge hyphens (leading/trailing, e.g. a sentence-terminating `#tag-`) are
- *     stripped; a tag that collapses to empty is dropped;
- *   - markdown `## heading` never matches (the second `#`/space is not in the
- *     allowed set).
- *
- * Pure module: no store, no side effects — persistence (store.setMemoryTags)
- * is a separate step. sanitizeTags shares the same validation so LLM-extracted
- * tag arrays (autoDream tag-extractor) are filtered identically.
- */
-
-export const MAX_TAG_LENGTH = 20;
-
-// `一` (U+4E00) .. `龥` (U+9FA5) is the CJK Unified Ideographs block (the
-// rule's `一-龥`). Matching requires a tag character right after `#` so a bare
-// `#` and markdown `## heading` are naturally excluded (#/space not in set).
-const TAG_RE = /#[a-zA-Z0-9_一-龥-]+/g;
-const EDGE_HYPHEN = /^-+|-+$/g;
-const VALID_TAG = /^[a-zA-Z0-9_一-龥-]+$/;
-
-/** Validate + dedupe an array of tag strings. Non-strings, blanks, over-long
- *  and illegal-character tags are dropped (fail-safe). A leading `#` is
- *  tolerated so raw LLM output can be passed through directly. */
-export function sanitizeTags(tags) {
-  if (!Array.isArray(tags)) return [];
-  const seen = new Set();
-  const out = [];
-  for (const t of tags) {
-    if (typeof t !== "string") continue;
-    let tag = t.trim();
-    if (tag.startsWith("#")) tag = tag.slice(1);
-    tag = tag.replace(EDGE_HYPHEN, "");
-    if (!tag || tag.length > MAX_TAG_LENGTH) continue;
-    if (!VALID_TAG.test(tag)) continue;
-    if (seen.has(tag)) continue; // 去重（保留首次出现顺序）
-    seen.add(tag);
-    out.push(tag);
-  }
-  return out;
-}
-
-/** @returns {string[]} validated tags in source order, deduplicated. */
-export function parseTags(content) {
-  if (typeof content !== "string" || content.length === 0) return [];
-  const raw = [];
-  TAG_RE.lastIndex = 0;
-  let m;
-  while ((m = TAG_RE.exec(content)) !== null) raw.push(m[0]);
-  return sanitizeTags(raw);
-}

package/dsh-mneme/src/parser/wiki-link.js

@@ -1,38 +0,0 @@
-/**
- * Wiki-Link parser (v0.6.1). Given a memory's content, extract explicit
- * cross-memory links of the form [[target]] or [[显示|target]]:
- *   [[target]]      → { display: "target", target: "target" }
- *   [[显示|target]] → { display: "显示",  target: "target" }
- *
- * Unclosed / empty-target / multi-pipe / bracket-nested markers are treated as
- * illegal and ignored. Pure module: no store, no side effects — resolution is a
- * separate step (resolveWikiLink) that needs a store handle.
- */
-
-/** @returns {{display: string, target: string}[]} in source order. */
-export function parseWikiLinks(content) {
-  if (typeof content !== "string" || content.length === 0) return [];
-  const links = [];
-  // [^\[\]]* keeps a single match from crossing `]]`; an unclosed `[[` never
-  // matches, and `[[a [[b]] c]]` only yields the inner `[[b]]`.
-  const re = /\[\[([^\[\]]*)\]\]/g;
-  let m;
-  while ((m = re.exec(content)) !== null) {
-    const inner = m[1];
-    const parts = inner.split("|");
-    if (parts.length > 2) continue; // 多管道 → 非法，忽略
-    const rawTarget = (parts.length === 2 ? parts[1] : parts[0]).trim();
-    if (!rawTarget) continue; // 空目标 → 非法，忽略
-    const rawDisplay = parts[0].trim();
-    links.push({ display: rawDisplay || rawTarget, target: rawTarget });
-  }
-  return links;
-}
-
-/** Resolve a wiki-link target title to a memory row via a case-insensitive
- *  exact title match (store.findByTitle). Returns undefined when absent or the
- *  store exposes no such lookup. */
-export function resolveWikiLink(store, title) {
-  if (!store || typeof title !== "string" || !title.trim()) return undefined;
-  return store.findByTitle?.(title.trim());
-}

package/dsh-mneme/src/search/tag-boost.js

@@ -1,61 +0,0 @@
-// v0.6.4 Tag-weighted re-rank helpers.
-// Query tags come from `#hashtags` in the query plus any known tags the query
-// mentions; candidates whose tags overlap the query tags or the session's
-// hot-memory tags get their score boosted before the final top-K cut.
-
-/**
- * Extract tags from a query: explicit `#hashtags` (CJK allowed) plus known
- * tags whose lowercase form appears in the query. Deduped, order-preserving.
- */
-export function extractQueryTags(query, knownTags = []) {
-  if (typeof query !== "string" || !query) return [];
-  const set = new Set();
-  const re = /#([a-zA-Z0-9_一-龥-]+)/g;
-  let m;
-  while ((m = re.exec(query)) !== null) set.add(m[1]);
-  const q = query.toLowerCase();
-  for (const t of knownTags) {
-    if (typeof t === "string" && q.includes(t.toLowerCase())) set.add(t);
-  }
-  return Array.from(set);
-}
-
-function hasOverlap(a, b) {
-  if (!Array.isArray(a) || !Array.isArray(b)) return false;
-  const setB = new Set(b);
-  return a.some((x) => setB.has(x));
-}
-
-/**
- * Boost candidate scores by tag overlap with the query and/or session tags.
- * Each candidate is expected to carry a `tags` array (enriched by the caller).
- * Returns a new array sorted by boosted score descending; candidates that were
- * boosted are marked `tagBoost: true`. Unchanged candidates keep their
- * relative order (stable).
- */
-export function applyTagBoost(
-  candidates,
-  { queryTags = [], sessionTags = [], factor = 1.15, sessionFactor = 1.08 }
-) {
-  const boosted = candidates.map((c) => {
-    const tags = c.tags ?? [];
-    let score = typeof c.score === "number" ? c.score : 0;
-    let didBoost = false;
-
-    if (queryTags.length && hasOverlap(tags, queryTags)) {
-      score = Math.min(1, score * factor);
-      didBoost = true;
-    }
-    if (sessionTags.length && hasOverlap(tags, sessionTags)) {
-      score = Math.min(1, score * sessionFactor);
-      didBoost = true;
-    }
-
-    const out = { ...c, score };
-    if (didBoost) out.tagBoost = true;
-    return out;
-  });
-
-  boosted.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
-  return boosted;
-}