@max-null/dsh-memory 0.2.1 → 0.3.7

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+export declare const inject: string[];
+export declare function apply(ctx: unknown): void;

package/dist/client/index.js

@@ -0,0 +1,283 @@
+/**
+ * @max-null/dsh-memory browser half (0.3.3): the memory panel, moved home
+ * from dsh-ssid-panels (2026-08-19 用户: 记忆面板应跟随 dsh-memory)。
+ * Data goes straight through the Typert `remote.memory` surface
+ * (list/search/confirm/forget/setInjected/reload) — no /ssid/api bridge,
+ * so any profile with dsh-memory gets the panel. Hosted on better-sidebar
+ * as an optional peer (same pattern dsh-ssid-panels used); without it the
+ * client half registers nothing.
+ */
+import { createElement, useEffect, useState } from 'react';
+export const inject = ['slots', 'locale', 'remote', 'remote.memory'];
+const STRINGS = {
+    zh: {
+        tabMemory: '记忆',
+        memorySearch: '搜索记忆…',
+        empty: '黑暗中未见灵光',
+        confirm: '确认',
+        forget: '删除',
+        groupPending: '待审核',
+        groupOnDemand: '已审核 · 按需',
+        groupInjected: '常驻注入',
+        injectSwitch: '常驻注入',
+        approveFirst: '审核通过后可常驻注入',
+        allNamespaces: '全部',
+        nsGlobal: '全局',
+        nsProject: '项目',
+        organizeMemory: '整理记忆',
+        confirmAll: '全部确认',
+        suggested: '待审核',
+        approved: '已审核',
+        refresh: '刷新',
+    },
+    en: {
+        tabMemory: 'Memory',
+        memorySearch: 'Search memory…',
+        empty: 'No spark in the dark',
+        confirm: 'Confirm',
+        forget: 'Forget',
+        groupPending: 'Pending review',
+        groupOnDemand: 'Approved · on demand',
+        groupInjected: 'Always injected',
+        injectSwitch: 'Inject every turn',
+        approveFirst: 'Approve to enable injection',
+        allNamespaces: 'All',
+        nsGlobal: 'Global',
+        nsProject: 'Project',
+        organizeMemory: 'Organize memory',
+        confirmAll: 'Approve all',
+        suggested: 'Suggested',
+        approved: 'Approved',
+        refresh: 'Refresh',
+    },
+};
+let localeId = 'zh';
+const localeListeners = new Set();
+function adoptLocale(id) {
+    const next = id === 'en' ? 'en' : 'zh';
+    if (next === localeId)
+        return;
+    localeId = next;
+    localeListeners.forEach(l => l());
+}
+function fmt(tpl, vars = {}) {
+    return tpl.replace(/\{(\w+)\}/g, (_, k) => String(vars[k] ?? ''));
+}
+function useT() {
+    const [id, setId] = useState(localeId);
+    useEffect(() => {
+        const l = () => { setId(localeId); };
+        localeListeners.add(l);
+        return () => { localeListeners.delete(l); };
+    }, []);
+    return (key, vars) => fmt(STRINGS[id][key] ?? STRINGS.zh[key], vars);
+}
+// ---- inline-styled primitives (no CSS build step) ----
+const ssid = {
+    accent: '#4FC3F7',
+    wrap: { display: 'flex', flexDirection: 'column', gap: 8, padding: '10px 12px', overflowY: 'auto', height: '100%', boxSizing: 'border-box' },
+    card: {
+        background: 'var(--dsw-alias-bg-layer-1, #131a26)',
+        border: '1px solid var(--dsw-alias-border-l2, #1e2836)',
+        borderRadius: 10,
+        padding: '10px 12px',
+    },
+    title: { fontSize: 12, fontWeight: 600, color: 'var(--dsw-alias-label-secondary, #67748a)', marginBottom: 6, display: 'flex', justifyContent: 'space-between', alignItems: 'center' },
+    text: { fontSize: 12.5, color: 'var(--dsw-alias-label-primary, #d8e0ea)', lineHeight: 1.55 },
+    muted: { fontSize: 11, color: 'var(--dsw-alias-label-secondary, #67748a)' },
+    empty: { padding: '28px 12px', textAlign: 'center', fontSize: 12.5, color: 'var(--dsw-alias-label-secondary, #67748a)' },
+    btn: {
+        padding: '3px 12px', fontSize: 11.5, background: 'none',
+        border: '1px solid var(--dsw-alias-border-l2, #1e2836)', borderRadius: 6,
+        color: 'var(--dsw-alias-label-primary, #d8e0ea)', cursor: 'pointer',
+    },
+};
+// 预填指令（0.3.1+）：过时内容用 memory_update 修正；工具面自查法。
+const ORGANIZE_PROMPT = '请整理我的记忆库：用 memory_list 查看全部记忆，合并重复或可归并的条目，精简冗长内容，为每条补充或修正 keywords；对过时、错误或已变化的内容用 memory_update 修正（会重置为待审核），需要删除的用 memory_forget，需要新增的用 memory_save。判断内容是否过时的方法：把记忆里提到的工具名/数量与你当前实际可用的记忆工具对照——你当前可用：memory_save / memory_list / memory_search / memory_confirm / memory_forget / memory_update（共 6 个）；若记忆中的工具列表、数量、流程与此不符即为过时，用 memory_update 修正。改动全部落在 suggested 等待审核（不要调用 memory_confirm），完成后用一句话汇报整理结果。';
+function MemoryView(props) {
+    const t = useT();
+    const [records, setRecords] = useState([]);
+    const [query, setQuery] = useState('');
+    const [namespace, setNamespace] = useState(null);
+    const [refreshing, setRefreshing] = useState(false);
+    const [organizing, setOrganizing] = useState(false);
+    const reload = async () => {
+        try {
+            setRecords(await props.remote.list());
+        }
+        catch {
+            setRecords([]);
+        }
+    };
+    // 强制重读存储文件（JsonStorageBackend 无 watch——外部编辑后必须 reload）
+    const refreshFromDisk = async () => {
+        setRefreshing(true);
+        try {
+            const value = await props.remote.reload();
+            setRecords(value);
+        }
+        catch {
+            await reload();
+        }
+        finally {
+            setRefreshing(false);
+        }
+    };
+    useEffect(() => { if (props.visible)
+        void reload(); }, [props.visible]);
+    const toggleInjected = async (record) => {
+        if (record.status !== 'approved')
+            return;
+        try {
+            await props.remote.setInjected(record.id, !record.injected);
+        }
+        catch {
+            /* 失败保持原状态 */
+        }
+        await reload();
+    };
+    const confirmAll = async () => {
+        const pending = records.filter(record => record.status === 'suggested');
+        if (pending.length === 0)
+            return;
+        await Promise.all(pending.map(record => props.remote.confirm(record.id).catch(() => null)));
+        await reload();
+    };
+    // 一点即发整理：sessions.create → open → input 就绪（轮询 ≤5s）→ setDraft → submit。
+    // 机制实证自 dsh-better-sidebar conversation-draft.ts；sessions/conversation 软获取。
+    const organize = async () => {
+        if (organizing)
+            return;
+        setOrganizing(true);
+        try {
+            const sessions = props.ctx.get?.('sessions');
+            const conversation = props.ctx.get?.('conversation');
+            if (sessions === undefined || conversation?.input?.for === undefined) {
+                throw new Error('sessions/conversation unavailable');
+            }
+            const sessionId = await sessions.create({});
+            sessions.open(sessionId);
+            let input;
+            for (let i = 0; i < 50; i++) {
+                try {
+                    const actx = sessions.scope(sessionId);
+                    if (actx !== undefined) {
+                        input = conversation.input.for(actx);
+                        if (input !== undefined)
+                            break;
+                    }
+                }
+                catch {
+                    /* not ready yet */
+                }
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            }
+            if (input === undefined)
+                throw new Error('composer input not ready');
+            input.setDraft(ORGANIZE_PROMPT);
+            input.submit();
+        }
+        catch (error) {
+            console.warn('[dsh-memory] organize memory failed:', error);
+        }
+        finally {
+            setOrganizing(false);
+        }
+    };
+    const q = query.trim().toLowerCase();
+    const byNs = namespace === null ? records : records.filter(record => record.namespace === namespace);
+    const filtered = byNs.filter(record => q === '' || record.content.toLowerCase().includes(q));
+    const groups = [
+        { key: 'pending', label: t('groupPending'), items: filtered.filter(record => record.status === 'suggested') },
+        { key: 'ondemand', label: t('groupOnDemand'), items: filtered.filter(record => record.status === 'approved' && !record.injected) },
+        { key: 'injected', label: t('groupInjected'), items: filtered.filter(record => record.status === 'approved' && record.injected) },
+    ].filter(group => group.items.length > 0);
+    return createElement('div', { style: ssid.wrap }, createElement('div', { style: { display: 'flex', gap: 6 } }, createElement('button', {
+        type: 'button',
+        title: t('organizeMemory'),
+        onClick: () => { void organize(); },
+        disabled: organizing,
+        style: { ...ssid.btn, color: ssid.accent, borderColor: ssid.accent },
+    }, organizing ? '…' : t('organizeMemory')), createElement('input', {
+        value: query,
+        onChange: (event) => { setQuery(event.target.value); },
+        placeholder: t('memorySearch'),
+        style: {
+            flex: 1, padding: '6px 10px', fontSize: 12.5, boxSizing: 'border-box',
+            background: 'var(--dsw-alias-bg-layer-1, #0f141d)',
+            border: '1px solid var(--dsw-alias-border-l2, #1e2836)', borderRadius: 8,
+            color: 'var(--dsw-alias-label-primary, #d8e0ea)', outline: 'none',
+        },
+    }), createElement('button', {
+        type: 'button',
+        title: t('refresh'),
+        onClick: () => { void refreshFromDisk(); },
+        disabled: refreshing,
+        style: ssid.btn,
+    }, refreshing ? '…' : '↻')), createElement('div', { style: { display: 'flex', gap: 4 } }, [null, 'global', 'project'].map(ns => createElement('button', {
+        key: ns ?? 'all',
+        onClick: () => { setNamespace(ns); },
+        style: { flex: 1, ...ssid.btn, ...(namespace === ns ? { color: ssid.accent, borderColor: ssid.accent } : {}) },
+    }, ns === null ? t('allNamespaces') : ns === 'global' ? t('nsGlobal') : t('nsProject')))), groups.length === 0
+        ? createElement('div', { style: ssid.empty }, t('empty'))
+        : groups.map(group => createElement('div', { key: group.key, style: { display: 'flex', flexDirection: 'column', gap: 6 } }, createElement('div', { style: ssid.title }, createElement('span', null, group.label), createElement('div', { style: { display: 'flex', alignItems: 'center', gap: 6 } }, group.key === 'pending' && group.items.length > 0
+            ? createElement('button', {
+                type: 'button',
+                title: t('confirmAll'),
+                onClick: () => { void confirmAll(); },
+                style: { ...ssid.btn, padding: '1px 8px', fontSize: 10.5 },
+            }, t('confirmAll'))
+            : null, createElement('span', null, `${group.items.length}`))), group.items.map(record => createElement('div', { key: record.id, style: ssid.card }, createElement('div', { style: ssid.text }, record.content), createElement('div', { style: { ...ssid.muted, marginTop: 6 } }, `${record.namespace} · ${record.status === 'approved' ? t('approved') : t('suggested')}${record.injected ? ` · ${t('groupInjected')}` : ''}`), createElement('div', { style: { display: 'flex', gap: 6, marginTop: 8, alignItems: 'center' } }, createElement('button', {
+            type: 'button',
+            title: record.status === 'approved' ? t('injectSwitch') : t('approveFirst'),
+            disabled: record.status !== 'approved',
+            onClick: () => { void toggleInjected(record); },
+            style: {
+                ...ssid.btn,
+                ...(record.injected ? { color: ssid.accent, borderColor: ssid.accent } : {}),
+                opacity: record.status !== 'approved' ? 0.4 : 1,
+                cursor: record.status !== 'approved' ? 'not-allowed' : 'pointer',
+            },
+        }, record.injected ? `✓ ${t('injectSwitch')}` : t('injectSwitch')), record.status === 'suggested'
+            ? createElement('button', {
+                style: ssid.btn,
+                onClick: () => { void props.remote.confirm(record.id).then(() => reload()); },
+            }, t('confirm'))
+            : null, createElement('button', {
+            style: ssid.btn,
+            onClick: () => { void props.remote.forget(record.id).then(() => reload()); },
+        }, t('forget'))))))));
+}
+// ---- client plugin body ----
+export function apply(ctx) {
+    const face = ctx;
+    const locale = face.get?.('locale');
+    const initial = locale?.getLocale?.()?.active;
+    if (typeof initial === 'string')
+        adoptLocale(initial);
+    face.on?.('locale/change', (snap) => { adoptLocale(snap?.active); });
+    // better-sidebar 可选软依赖：无则面板不注册（host 侧无影响）。
+    const root = ctx;
+    if (root.inject === undefined)
+        return;
+    root.inject(['betterSidebar'], (sidebarCtx) => {
+        const service = sidebarCtx.betterSidebar;
+        if (service?.registerTab === undefined)
+            return;
+        const memory = ctx.remote?.memory;
+        if (memory === undefined)
+            return;
+        const tabCtx = ctx;
+        service.registerTab({
+            id: '@max-null/dsh-memory:memory',
+            title: () => STRINGS[localeId].tabMemory,
+            order: 60,
+            single: true,
+            component: ({ visible }) => createElement(MemoryView, {
+                visible,
+                remote: memory,
+                ctx: tabCtx,
+            }),
+        });
+    });
+}

package/dist/engine.d.ts

@@ -13,12 +13,17 @@ export type MemoryId = string & {
 /** Brand a string as a {@link MemoryId} (compile-time only). */
 export declare function MemoryId(id: string): MemoryId;
 export type MemoryNamespace = 'global' | 'project';
-/** `suggested` is model-written; only a human confirmation promotes it. */
-export type MemoryStatus = 'suggested' | 'auto' | 'suggest';
+/**
+ * 审核维度（0.3.0）：`suggested` 待审核（模型写入）；`approved` 已人工
+ * 审核通过。注入与否由独立维度 `injected` 控制（见 MemoryRecord）。
+ */
+export type MemoryStatus = 'suggested' | 'approved';
 export interface MemoryRecord {
     id: MemoryId;
     namespace: MemoryNamespace;
     status: MemoryStatus;
+    /** 注入维度：true = 每轮全量注入 system prompt（常驻）；false = 仅检索。 */
+    injected: boolean;
     content: string;
     keywords: string[];
     createdAt: number;
@@ -32,6 +37,7 @@ export interface MemoryWrite {
 export interface MemoryFilter {
     namespace?: MemoryNamespace;
     status?: MemoryStatus;
+    injected?: boolean;
 }
 export interface MemoryHit {
     record: MemoryRecord;
@@ -48,6 +54,10 @@ export type MemoryChange = {
     operation: 'status';
     id: MemoryId;
     status: MemoryStatus;
+} | {
+    operation: 'injected';
+    id: MemoryId;
+    injected: boolean;
 };
 declare module '@deepseek-ai/cordis' {
     interface Context {
@@ -67,30 +77,65 @@ export interface MemoryConfig {
 }
 /**
  * Cross-session plaintext memory over the storage hub, split by namespace:
- * `global` lives in the harness home, `project` in the project folder.
+ * `global` lives in the harness home, `project` in the session's workspace
+ * folder (`<workspace>/.dsh/storages`, follows the repository) — 0.3.4:
+ * project memory routes by the CALLER's workspace cwd (工具/面板按当前会话
+ * 工作区路由), not the process launch dir.
  */
 export declare class MemoryEngine extends Service {
     private readonly config;
     static inject: string[];
     private globalTable?;
-    private projectTable?;
+    /** project 域按工作区 cwd 懒打开 + 缓存（多会话并发各工作区独立）。 */
+    private projectTables;
+    private projectFacilities;
+    /** backend 只注册一次（registry 重名抛 duplicate；reload 清缓存后不得重复注册）。 */
+    private registeredProjectBackends;
     private facility?;
     constructor(ctx: import('@deepseek-ai/cordis').Context, config?: MemoryConfig);
     protected [Service.init](): Promise<void>;
-    /** 打开两个存储域（init 与 reload 共用）。 */
-    private openDomains;
+    /** 打开全局存储域（init 与 reload 共用；backend 复用已注册实例）。 */
+    private openGlobalFacility;
+    /** 工作区 project 存储根（<workspace>/.dsh/storages，随 git 分享）。 */
+    private projectRootFor;
+    /** 稳定 backend 名（registry 重名抛错，按 cwd hash 唯一化；只允许 [a-z0-9_]，domain 名校验）。 */
+    private projectBackendName;
+    /**
+     * 按工作区 cwd 取 project 表（懒打开 + 缓存）。无 cwd（未选工作区）
+     * 返回 undefined——调用方（工具/面板）按此跳过 project 部分。
+     */
+    private projectTableFor;
     /**
-     * 强制重载存储：关闭两域后重开，放弃内存缓存重读文件。
-     * 供外部编辑记忆文件后刷新（JsonStorageBackend 打开时加载一次，
-     * 无 watch——2026-08-19 用户实测面板不感知外部编辑）。
+     * 强制重载存储：关闭全局域与全部已开工作区域后重开（unit 释放后
+     * backend 重读文件），放弃内存缓存。供外部编辑记忆文件后刷新
+     * （JsonStorageBackend 打开时加载一次，无 watch——2026-08-19 实测）。
      */
     reload(): Promise<void>;
     /** Create one record in `suggested` status — never self-promoting. */
-    remember(input: MemoryWrite): Promise<MemoryRecord>;
-    list(filter?: MemoryFilter): MemoryRecord[];
-    search(query: string, filter?: MemoryFilter): MemoryHit[];
-    forget(id: MemoryId): Promise<boolean>;
-    setStatus(id: MemoryId, status: MemoryStatus): Promise<MemoryRecord>;
+    remember(input: MemoryWrite, projectCwd?: string): Promise<MemoryRecord>;
+    list(filter?: MemoryFilter, projectCwd?: string): Promise<MemoryRecord[]>;
+    search(query: string, filter?: MemoryFilter, projectCwd?: string): Promise<MemoryHit[]>;
+    forget(id: MemoryId, projectCwd?: string): Promise<boolean>;
+    setStatus(id: MemoryId, status: MemoryStatus, projectCwd?: string): Promise<MemoryRecord>;
+    /**
+     * 注入维度开关（0.3.0）：只改 injected，不动审核状态。供 UI 面板
+     * 「常驻注入」开关调用（remote.setInjected）。
+     */
+    setInjected(id: MemoryId, injected: boolean, projectCwd?: string): Promise<MemoryRecord>;
+    /**
+     * 修改一条记忆的内容/关键词（0.3.1 整理记忆用）。内容被模型改动后
+     * 必须重新人工审核：status 重置为 suggested（自然停止注入——注入仅对
+     * approved 生效）；injected 保留原值（审核通过后注入开关原样恢复）。
+     */
+    update(id: MemoryId, patch: {
+        content?: string;
+        keywords?: string[];
+    }, projectCwd?: string): Promise<MemoryRecord>;
+    /**
+     * 注入专用（0.3.4）：systemPrompt context 是同步回调、无会话 cwd 可及，
+     * 只返回 global 的 approved+injected（工作区记忆走检索/面板）。
+     */
+    recallRecords(): MemoryRecord[];
     private allRecords;
     private recordsOf;
     private tableFor;