dsh-prime-memory 0.18.4 → 0.18.6

package/dist/embedding-worker.cjs

@@ -1,176 +0,0 @@
-/**
- * 本地嵌入 worker:transformers.js 的模型加载与推理在本线程执行,主线程只
- * 投递文本、收回向量。onnxruntime-node 的 run/loadModel 是 setImmediate 回调里
- * 的同步调用(Promise 包装不卸载计算),留在主线程会冻结宿主事件循环——
- * dsh 页面一切交互无响应数秒的根因。
- *
- * 协议(与 src/store/local-embedding.ts 的 RealWorkerChannel 配对;自增 id):
- * - 入向:{id,type:'ping'} | {id,type:'warmup'} | {id,type:'embed',texts,priority}
- * - 出向:{id,ok:true,type:'pong'|'ready'|'embedded',vectors?}(向量经
- *   transfer 列表零拷贝回传)| {id,ok:false,stage:'load'|'infer',error}
- *   | {type:'fatal',error}
- *
- * 调度:单线程串行。embedBatch 拆成逐条 job、条间 setImmediate 让路——
- * 单条请求(priority,即召回 query)unshift 插队,最坏只等"正在算的那一条",
- * 不会被 reindex 批次(16/32 条 ≈5-10s)堵在队尾。
- *
- * 信任边界(沿 AGENTS.md 审查记录):runtime/ 目录在数据目录信任边界内,
- * 本线程按其 package.json createRequire 加载 transformers——对数据目录有写
- * 权限的进程理论上可植入恶意模块;模型文件逐文件 sha256 锁定,运行时代码
- * 无同级防护,完整修复需安装指纹设计,暂以文档化假设为准。
- */
-'use strict';
-
-const { parentPort, workerData } = require('node:worker_threads');
-const path = require('node:path');
-const { createRequire } = require('node:module');
-
-/** 错误消息归一化(Error 取 message,其余 String 化)。 */
-function errMsg(err) {
-  return err && err.message ? err.message : String(err);
-}
-
-const cfg = workerData || {};
-const RUNTIME_DIR = typeof cfg.runtimeDir === 'string' ? cfg.runtimeDir : '';
-const MODEL_DIR = typeof cfg.modelDir === 'string' ? cfg.modelDir : '';
-const POOLING = cfg.pooling === 'cls' ? 'cls' : 'mean';
-const DTYPE = typeof cfg.dtype === 'string' ? cfg.dtype : 'q8';
-const MAX_INPUT_CHARS = cfg.maxInputChars > 0 ? cfg.maxInputChars : 5000;
-
-let extractor = null; // pipeline('feature-extraction', …)
-let loadState = 'idle'; // idle | loading | ready | failed
-let loadPromise = null;
-let loadError = null;
-
-// ── 模型懒加载(首请求触发;失败后经 warmup 可重试,embed 请求失败快返回) ──
-function ensureLoaded() {
-  if (loadState === 'ready') return Promise.resolve();
-  if (loadState === 'loading' && loadPromise) return loadPromise;
-  loadState = 'loading';
-  loadError = null;
-  loadPromise = (async () => {
-    try {
-      if (!RUNTIME_DIR || !MODEL_DIR) throw new Error('workerData 缺少 runtimeDir/modelDir');
-      const req = createRequire(path.join(RUNTIME_DIR, 'package.json'));
-      const mod = req('@huggingface/transformers');
-      if (mod.env) {
-        mod.env.allowRemoteModels = false;
-        if (mod.env.allowLocalModels !== undefined) mod.env.allowLocalModels = true;
-      }
-      extractor = await mod.pipeline('feature-extraction', MODEL_DIR, { dtype: DTYPE });
-      loadState = 'ready';
-    } catch (err) {
-      loadState = 'failed';
-      loadError = errMsg(err);
-      loadPromise = null; // 失败后下一次 warmup 重新走加载
-      throw err;
-    }
-  })();
-  return loadPromise;
-}
-
-// ── 推理队列(逐条 job;priority 插队;条间让路) ──
-const queue = []; // [{ request, index, text }]
-let pumping = false;
-
-function postReply(msg, transfer) {
-  parentPort.postMessage(msg, transfer || []);
-}
-
-/** 请求全部条目完成 → 回执(transfer 向量缓冲零拷贝)。 */
-function settle(request) {
-  if (request.failed || request.remaining !== 0) return;
-  postReply(
-    { id: request.id, ok: true, type: 'embedded', vectors: request.vectors },
-    request.vectors.map((v) => v.buffer),
-  );
-}
-
-/** 首个失败即回执错误,并移除该请求尚未开跑的条目(正在跑的至多 1 条,算完即弃)。 */
-function failRequest(request, error, stage) {
-  if (request.failed) return;
-  request.failed = true;
-  for (let i = queue.length - 1; i >= 0; i--) {
-    if (queue[i].request === request) queue.splice(i, 1);
-  }
-  postReply({ id: request.id, ok: false, stage: stage, error: errMsg(error) });
-}
-
-async function pump() {
-  if (pumping) return;
-  pumping = true;
-  try {
-    while (queue.length > 0) {
-      const job = queue.shift();
-      if (job.request.failed) continue;
-      try {
-        const result = await extractor([job.text.slice(0, MAX_INPUT_CHARS)], { pooling: POOLING, normalize: true });
-        const data = result[0] && result[0].data;
-        job.request.vectors[job.index] = data instanceof Float32Array ? data : new Float32Array(data);
-        job.request.remaining -= 1;
-        settle(job.request);
-      } catch (err) {
-        failRequest(job.request, err, 'infer');
-      }
-      // 条间让路:交还本线程事件循环,新消息(含 priority 插队)可在批间被处理
-      await new Promise((resolve) => setImmediate(resolve));
-    }
-  } finally {
-    pumping = false;
-  }
-}
-
-function handleEmbed(msg) {
-  const texts = Array.isArray(msg.texts) ? msg.texts : [];
-  if (texts.length === 0) {
-    postReply({ id: msg.id, ok: true, type: 'embedded', vectors: [] });
-    return;
-  }
-  const request = { id: msg.id, vectors: new Array(texts.length), remaining: texts.length, failed: false };
-  // 单条请求(召回 query)插队到队首;批次追加到队尾(批内条目间仍会被后来的插队)
-  const priority = msg.priority === true && texts.length === 1;
-  for (let i = 0; i < texts.length; i++) {
-    const job = { request: request, index: i, text: String(texts[i] == null ? '' : texts[i]) };
-    if (priority) queue.unshift(job);
-    else queue.push(job);
-  }
-  void pump();
-}
-
-parentPort.on('message', (msg) => {
-  if (!msg || typeof msg.id !== 'number' || typeof msg.type !== 'string') return;
-  if (msg.type === 'ping') {
-    postReply({ id: msg.id, ok: true, type: 'pong' });
-    return;
-  }
-  if (msg.type === 'warmup') {
-    ensureLoaded().then(
-      () => postReply({ id: msg.id, ok: true, type: 'ready' }),
-      () => postReply({ id: msg.id, ok: false, stage: 'load', error: loadError ?? '模型加载失败' }),
-    );
-    return;
-  }
-  if (msg.type === 'embed') {
-    void (async () => {
-      try {
-        await ensureLoaded();
-      } catch {
-        postReply({ id: msg.id, ok: false, stage: 'load', error: loadError ?? '模型加载失败' });
-        return;
-      }
-      handleEmbed(msg);
-    })();
-    return;
-  }
-});
-
-// 未捕获异常:尽力通知主线程后强制退出(主线程的 exit 处理会拒绝全部 pending
-// 并转入 failed 态)。不保持半死状态——半死的 worker 只会让调用方挂到超时。
-process.on('uncaughtException', (err) => {
-  try {
-    postReply({ type: 'fatal', error: errMsg(err) });
-  } catch {
-    /* 端口已坏,exit 处理兜底 */
-  }
-  setTimeout(() => process.exit(1), 50);
-});

package/dist/hall-backfill.d.ts

@@ -1,33 +0,0 @@
-/**
- * 存量未打标记录的一键回填(task_15):从 HallWheel"未打标 M"入口触发,
- * 对 metadata 无 hall 的 L1 记录按 8 角词表批量补打标签(复用 L1 抽取的打标路径:
- * 同一候选词表与措辞,经既有蒸馏 LLM 路由)。
- *
- * 安全边界:
- * - **单飞**:同时最多一个回填任务,重复触发直接返回 running(不排队不叠加);
- * - **后台执行**:端点立即返回,逐块推进(每块 20 条),不阻塞 RPC/管线;
- * - **失败可退**:LLM 失败/输出不合法只跳过当前块,原记录零改动(标签只写成功的);
- * - **有界**:单次任务最多处理 MAX_RECORDS 条,防止一次跑飞;其余可再次触发。
- */
-import type { Context } from '@deepseek-ai/cordis';
-import { type MemoryLogger } from './types.js';
-import type { L1Store } from './store/l1.js';
-import type { MemoryConfig } from './config.js';
-export interface HallBackfillDeps {
-    ctx: Context;
-    cfg: MemoryConfig;
-    l1: L1Store;
-    logger: MemoryLogger;
-}
-export interface HallBackfillState {
-    running: boolean;
-    /** 本进程累计成功打标条数(重启归零;仅作观测,不作账)。 */
-    updated: number;
-    failed: number;
-}
-export declare function hallBackfillState(): HallBackfillState;
-/** 启动后台回填;已在运行返回 false(单飞)。 */
-export declare function startHallBackfill(deps: HallBackfillDeps): {
-    started: boolean;
-    running: boolean;
-};

package/dist/hall-backfill.js

@@ -1,95 +0,0 @@
-import { callLLM } from './llm.js';
-import { normHallEnabled } from './config.js';
-import { HALL_FALLBACK } from './types.js';
-import { parseJsonLogged } from './llm.js';
-/** 单次任务处理上限(524 条存量一次跑完约为 LLM 成本大头;分批触发,可重复执行)。 */
-const MAX_RECORDS = 300;
-/** 每块条数(一次 LLM 调用判定的记录数)。 */
-const CHUNK = 20;
-const state = { running: false, updated: 0, failed: 0 };
-export function hallBackfillState() {
-    return { ...state };
-}
-const SYSTEM_PROMPT = '你是记忆库的域标注器。给你若干条记忆(带 id),为每条判断其内容属于哪个 Hall 域,输出 JSON 数组:' +
-    '[{"id":"<原id>","hall":"<域id>"}]。hall 只能从给定候选列表中选;横跨多域或确实无法归入任何角时选 general。' +
-    '只输出 JSON,不要多余文字。';
-/** 启动后台回填;已在运行返回 false(单飞)。 */
-export function startHallBackfill(deps) {
-    if (state.running)
-        return { started: false, running: true };
-    state.running = true;
-    state.updated = 0;
-    state.failed = 0;
-    void run(deps).finally(() => {
-        state.running = false;
-        deps.logger.info(`[memory] hall 回填结束:成功 ${state.updated} 条,失败 ${state.failed} 条`);
-    });
-    return { started: true, running: true };
-}
-async function run(deps) {
-    const { ctx, cfg, l1, logger } = deps;
-    const halls = normHallEnabled(cfg.hall?.enabled);
-    if (halls.length === 0) {
-        logger.warn('[memory] hall 回填跳过:hall.enabled 为空(打标功能已关闭)');
-        return;
-    }
-    const candidates = [...halls, HALL_FALLBACK].join(' / ');
-    // 未打标集:主表全量里的 null hall(含 retired 行——restore 后标签已补,不重扫)
-    const all = l1.all();
-    const pending = all.filter((r) => !(r.metadata && typeof r.metadata.hall === 'string' && r.metadata.hall !== ''));
-    let budget = Math.min(pending.length, MAX_RECORDS);
-    logger.info(`[memory] hall 回填启动:未打标 ${pending.length} 条,本次上限 ${budget} 条(候选 ${candidates})`);
-    for (let offset = 0; offset < pending.length && budget > 0; offset += CHUNK) {
-        const chunk = pending.slice(offset, offset + CHUNK).filter(pickChunk);
-        if (chunk.length === 0)
-            continue;
-        budget -= chunk.length;
-        const labeled = await labelChunk(ctx, cfg, logger, chunk, candidates);
-        for (const { record, hall } of labeled) {
-            // 原记录最小改动:metadata.hall 单键写入,其余字段原样 upsert(同 id 版本不变语义)
-            const next = { ...record, metadata: { ...(record.metadata ?? {}), hall } };
-            try {
-                await l1.upsert(next);
-                state.updated++;
-            }
-            catch {
-                state.failed++;
-            }
-        }
-    }
-}
-/** 回填只处理活跃记录可安全加速,但 retired 行的 metadata_json 同样保留且 restore 后可见——
- *  upsert 对 retired 行的行为由存储层保证(同 id 覆盖不复活),这里不做活性过滤,口径与迁移一致(全量)。 */
-function pickChunk(_r) {
-    return true;
-}
-async function labelChunk(ctx, cfg, logger, chunk, candidates) {
-    const list = chunk.map((r, i) => `${i + 1}. id=${r.id}\n${r.content.slice(0, 300)}`).join('\n\n');
-    const user = `候选 Hall:${candidates}\n\n记忆列表:\n${list}`;
-    try {
-        const raw = await callLLM(ctx, cfg, {
-            system: SYSTEM_PROMPT,
-            user,
-            maxTokens: 4096,
-            layer: 'l1-extract',
-            logger,
-        });
-        const parsed = parseJsonLogged(raw, 'hall 回填', logger);
-        if (!Array.isArray(parsed))
-            return [];
-        const byId = new Map(chunk.map((r) => [r.id, r]));
-        const out = [];
-        for (const item of parsed) {
-            const record = typeof item?.id === 'string' ? byId.get(item.id) : undefined;
-            const hall = typeof item?.hall === 'string' ? item.hall.trim() : '';
-            if (record && hall)
-                out.push({ record, hall });
-        }
-        return out;
-    }
-    catch (err) {
-        logger.warn(`[memory] hall 回填块失败(跳过 ${chunk.length} 条,原记录未改): ${err instanceof Error ? err.message : String(err)}`);
-        state.failed += chunk.length;
-        return [];
-    }
-}

package/dist/hall-migrate.d.ts

@@ -1,32 +0,0 @@
-import type { MemoryLogger } from './types.js';
-/** 新词表下的全部合法 hall 值(8 角 + 跨域兜底)。 */
-export declare const HALL_VALID_VALUES: readonly string[];
-export interface HallMigrationReport {
-    dbPath: string;
-    dryRun: boolean;
-    /** 主表全量行数(含 retired;与 hallL1Counts 的扫描口径一致)。 */
-    total: number;
-    /** retired 行数(valid_to 非空或带退场标记——迁移**不加过滤**,全量扫描自动覆盖)。 */
-    retired: number;
-    active: number;
-    /** 逐值计数(含 retired 行;null 单列)。 */
-    byHall: Record<string, number>;
-    unlabeled: number;
-    /** 不在新词表内的历史值(按 R10 不删已有标签,仅报告)。 */
-    unknownValues: Record<string, number>;
-    /** metadata 解析失败的行数(备份仍写入原始 JSON)。 */
-    corruptMetadata: number;
-    /** apply 模式写出的备份文件路径(dry-run 为 null)。 */
-    backupPath: string | null;
-    /** 结论:expected = 全部值合法(迁移无需改写);unknown = 存在历史遗留值(已报告,保留)。 */
-    verdict: 'expected' | 'unknown-values';
-}
-export interface HallMigrationOptions {
-    dbPath: string;
-    /** true = 只读报告,不写备份;false = 先备份 metadata_json 再出报告。 */
-    dryRun?: boolean;
-    /** 备份输出目录(缺省 = db 同目录 hall-migrate-backup/)。 */
-    backupDir?: string;
-    logger?: MemoryLogger;
-}
-export declare function runHallMigration(opts: HallMigrationOptions): HallMigrationReport;

package/dist/hall-migrate.js

@@ -1,88 +0,0 @@
-/**
- * hall 词表迁移(task_14):v0.12 5 值词表 → 8 角 + general 跨域兜底的**有界 targeted pass**。
- *
- * 关键事实(决定本迁移的形态):
- * - 4 个保留 id(work/relationships/finance/journey)在新词表下仍是合法角,**存量标签零改动**;
- * - `general` 保留为跨域兜底值(不重写、不删除);
- * - 4 个新角无存量。因此本迁移**不改任何行的 hall 值**——它做的是:
- *   ① 备份 metadata_json(apply 模式);② **扫 L1 主表全量(含 retired 行)**逐行核对;
- *   ③ 落报告:逐值计数(含 null)/活性与 retired 拆分/未知值清单。
- *
- * 幂等:连续执行两次报告一致(扫描是纯读)。共享扫描函数 = `MemoryDb.scanL1Metadata`
- * (单一所有者;计划 B 的引用门禁复用同一函数,不写第二份扫描)。
- */
-import { openSync, closeSync, writeSync, existsSync, mkdirSync } from 'node:fs';
-import * as path from 'node:path';
-import { MemoryDb } from './store/sqlite.js';
-import { HALL_CATALOG, HALL_FALLBACK } from './types.js';
-/** 新词表下的全部合法 hall 值(8 角 + 跨域兜底)。 */
-export const HALL_VALID_VALUES = [...HALL_CATALOG.map((h) => h.id), HALL_FALLBACK];
-export function runHallMigration(opts) {
-    const db = new MemoryDb(opts.dbPath, 0, opts.logger);
-    // 开库即建表/补列(CREATE TABLE IF NOT EXISTS 惯例);未 init 则句柄未打开,扫描恒 0
-    db.init();
-    try {
-        const report = {
-            dbPath: opts.dbPath,
-            dryRun: !!opts.dryRun,
-            total: 0,
-            retired: 0,
-            active: 0,
-            byHall: {},
-            unlabeled: 0,
-            unknownValues: {},
-            corruptMetadata: 0,
-            backupPath: null,
-            verdict: 'expected',
-        };
-        let backupFd = null;
-        if (!report.dryRun) {
-            const dir = opts.backupDir ?? path.join(path.dirname(opts.dbPath), 'hall-migrate-backup');
-            if (!existsSync(dir))
-                mkdirSync(dir, { recursive: true });
-            const backupPath = path.join(dir, `metadata-backup-${new Date().toISOString().replace(/[:.]/g, '-')}.jsonl`);
-            backupFd = openSync(backupPath, 'w');
-            report.backupPath = backupPath;
-        }
-        try {
-            report.total = db.scanL1Metadata((recordId, metadata) => {
-                const hall = metadata && typeof metadata.hall === 'string' && metadata.hall !== '' ? metadata.hall : null;
-                // metadata 缺失/解析失败与"无 hall"同样计入未打标(存量 524 null 的主口径)
-                // 备份:原始 metadata_json 原样落盘(apply 模式;dry-run 不写任何文件)
-                if (backupFd !== null) {
-                    writeSync(backupFd, JSON.stringify({ recordId, metadata }) + '\n');
-                }
-                if (hall === null) {
-                    report.unlabeled++;
-                }
-                else {
-                    report.byHall[hall] = (report.byHall[hall] ?? 0) + 1;
-                    if (!HALL_VALID_VALUES.includes(hall)) {
-                        report.unknownValues[hall] = (report.unknownValues[hall] ?? 0) + 1;
-                    }
-                }
-            });
-            // retired 拆分:退场判定与存储层同口径(valid_to 非空 ∨ dsh_superseded 标记)。
-            // 扫描本身**不加过滤**(全表 SELECT 自动覆盖 retired),这里仅分类计数。
-            report.active = report.total - countRetired(db);
-            report.retired = report.total - report.active;
-        }
-        finally {
-            if (backupFd !== null)
-                closeSync(backupFd);
-        }
-        report.verdict = Object.keys(report.unknownValues).length > 0 ? 'unknown-values' : 'expected';
-        return report;
-    }
-    finally {
-        db.close();
-    }
-}
-/** retired 行计数(与 sqlite 层退场判定同口径;用于验证"全量扫描不漏 retired")。 */
-function countRetired(db) {
-    // 借道 scanL1Metadata 之外的轻量路径不可得(retired 判定在行级字段),
-    // 这里直接用 hallL1Counts 的同族 SQL:valid_to 非空 ∨ metadata 带 dsh_superseded。
-    // 为保持"单一所有者",经由 scanL1Metadata 之外不再开第二条 SQL——改为返回占位 0,
-    // 由 retire 拆分调用方(db.retiredL1Count)提供。
-    return db.retiredL1Count();
-}