hyacinth-ai 0.9.6

package/dist/context/precision/companion.js

@@ -0,0 +1,144 @@
+/**
+ * CompanionStrategy — 陪伴模式。
+ *
+ * 不做关键词分析、不截断历史。
+ * filterHistory 移除所有包含工具调用或工具相关文本的回合，
+ * 保持陪伴对话纯净——陪伴模式下不应夹杂任何"元操作"痕迹。
+ */
+export class CompanionStrategy {
+    name = 'companion';
+    prepareCompose(_personaDir) {
+        return { personaDir: undefined };
+    }
+    filterHistory(history) {
+        return filterToolRounds(history);
+    }
+    async analyzeTurn(_messages, _provider) {
+        // 陪伴模式不需要关键词提取
+    }
+}
+/** 陪伴模式下的工具名 — 对话文本中出现即触发过滤 */
+const COMPANION_TOOL_NAMES = [
+    'companion_mode', 'reset_companion_session',
+    'add_task', 'list_tasks', 'remove_task', 'toggle_task',
+    'read', 'write', 'edit',
+];
+/** 工具相关关键词 — 只在 assistant 提到"能用/可用/有哪些"工具时触发 */
+const TOOL_KEYWORDS = [
+    '有哪些工具', '能用的工具', '可用工具', '工具列表',
+    '命令执行', 'bash', 'powershell', '终端命令',
+];
+/**
+ * 从历史消息中移除所有包含工具调用或工具相关文本的完整回合。
+ *
+ * 检测两类情况：
+ *   A. assistant 消息中包含 tool_use 块（实际调用了工具）
+ *   B. assistant 的文本中出现了工具名或关键词（"你有哪些工具可用？"→ 列工具名）
+ *
+ * 两种情况都会移除整轮：用户消息 + assistant 消息 + tool_result + 跟进文本。
+ */
+export function filterToolRounds(history) {
+    const dirtyIndices = new Set();
+    const allToolIds = new Set();
+    for (let i = 0; i < history.length; i++) {
+        const msg = history[i];
+        if (msg.role !== 'assistant')
+            continue;
+        const contents = Array.isArray(msg.content) ? msg.content : [msg.content];
+        // A. 检测 tool_use
+        for (const block of contents) {
+            if (block.type === 'tool_use') {
+                dirtyIndices.add(i);
+                allToolIds.add(block.id);
+            }
+        }
+        // B. 检测文本中的工具名/关键词
+        if (!dirtyIndices.has(i)) {
+            for (const block of contents) {
+                if (block.type === 'text') {
+                    const text = block.text;
+                    if (containsToolContent(text)) {
+                        dirtyIndices.add(i);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    // 也检测 user 消息文本中是否包含工具名（用户问"你有哪些工具"）
+    for (let i = 0; i < history.length; i++) {
+        if (dirtyIndices.has(i))
+            continue;
+        const msg = history[i];
+        if (msg.role !== 'user')
+            continue;
+        const text = typeof msg.content === 'string' ? msg.content : '';
+        if (text && containsToolContent(text)) {
+            // 用户问了工具相关 → 标记下一条 assistant 为 dirty
+            for (let j = i + 1; j < history.length; j++) {
+                if (history[j].role === 'assistant') {
+                    dirtyIndices.add(j);
+                    break;
+                }
+                if (history[j].role === 'user')
+                    break;
+            }
+        }
+    }
+    if (dirtyIndices.size === 0)
+        return history;
+    const removeIndices = new Set();
+    // 移除 dirty assistant + 前一条 user
+    for (const idx of dirtyIndices) {
+        removeIndices.add(idx);
+        if (idx > 0 && history[idx - 1].role === 'user') {
+            removeIndices.add(idx - 1);
+        }
+    }
+    // 移除对应的 tool_result
+    for (let i = 0; i < history.length; i++) {
+        const msg = history[i];
+        const contents = Array.isArray(msg.content) ? msg.content : [msg.content];
+        for (const block of contents) {
+            if (block.type === 'tool_result' &&
+                allToolIds.has(block.tool_use_id)) {
+                removeIndices.add(i);
+            }
+        }
+    }
+    // 移除跟进纯文本
+    const sortedDirty = [...dirtyIndices].sort((a, b) => a - b);
+    for (const idx of sortedDirty) {
+        let next = idx + 1;
+        while (next < history.length) {
+            if (removeIndices.has(next)) {
+                next++;
+                continue;
+            }
+            if (history[next].role === 'assistant') {
+                const raw = history[next].content;
+                const blocks = Array.isArray(raw) ? raw : [{ type: 'text' }];
+                if (blocks.every((c) => c.type === 'text')) {
+                    removeIndices.add(next);
+                    next++;
+                    continue;
+                }
+            }
+            break;
+        }
+    }
+    return history.filter((_, i) => !removeIndices.has(i));
+}
+function containsToolContent(text) {
+    const lower = text.toLowerCase();
+    for (const name of COMPANION_TOOL_NAMES) {
+        if (lower.includes(name))
+            return true;
+    }
+    for (const kw of TOOL_KEYWORDS) {
+        if (text.includes(kw))
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=companion.js.map

package/dist/context/precision/default.d.ts

@@ -0,0 +1,14 @@
+import type { Message } from '../../types.js';
+import type { Provider } from '../../provider/interface.js';
+import type { ComposeStrategy, ComposeStrategyOptions } from './types.js';
+/**
+ * DefaultStrategy — 普通模式。
+ * 所有方法均为透传，零性能损耗。
+ */
+export declare class DefaultStrategy implements ComposeStrategy {
+    name: string;
+    prepareCompose(personaDir: string | undefined): ComposeStrategyOptions;
+    filterHistory(history: Message[]): Message[];
+    analyzeTurn(_messages: Message[], _provider: Provider): Promise<void>;
+}
+//# sourceMappingURL=default.d.ts.map

package/dist/context/precision/default.js

@@ -0,0 +1,17 @@
+/**
+ * DefaultStrategy — 普通模式。
+ * 所有方法均为透传，零性能损耗。
+ */
+export class DefaultStrategy {
+    name = 'default';
+    prepareCompose(personaDir) {
+        return { personaDir, preciseMode: false };
+    }
+    filterHistory(history) {
+        return history;
+    }
+    async analyzeTurn(_messages, _provider) {
+        // 不做事
+    }
+}
+//# sourceMappingURL=default.js.map

package/dist/context/precision/index.d.ts

@@ -0,0 +1,9 @@
+export { DefaultStrategy } from './default.js';
+export { PreciseStrategy } from './strategy.js';
+export { CompanionStrategy } from './companion.js';
+export { KeywordPool } from './keyword-pool.js';
+export { SummaryStore } from './summary-store.js';
+export { analyzeConversation, matchHistory } from './analyzer.js';
+export type { ComposeStrategy, ComposeStrategyOptions, KeywordEntry } from './types.js';
+export type { TurnSummary, AnalysisResult } from './analyzer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/context/precision/index.js

@@ -0,0 +1,7 @@
+export { DefaultStrategy } from './default.js';
+export { PreciseStrategy } from './strategy.js';
+export { CompanionStrategy } from './companion.js';
+export { KeywordPool } from './keyword-pool.js';
+export { SummaryStore } from './summary-store.js';
+export { analyzeConversation, matchHistory } from './analyzer.js';
+//# sourceMappingURL=index.js.map

package/dist/context/precision/keyword-pool.d.ts

@@ -0,0 +1,27 @@
+import type { KeywordEntry } from './types.js';
+/**
+ * 关键词池 — 管理 session 内累积的关键词
+ * 每个 precise session 独立维护
+ */
+export declare class KeywordPool {
+    private keywords;
+    private filePath;
+    constructor(sessionDir: string);
+    /** 添加关键词（去重、加权重） */
+    add(keyword: string, weight?: number): void;
+    /** 批量添加 */
+    addAll(entries: KeywordEntry[]): void;
+    /** 获取所有关键词（按权重降序） */
+    getAll(): string[];
+    /** 获取 Top N */
+    getTop(n?: number): string[];
+    /** 关键词数量 */
+    size(): number;
+    /** 持久化到磁盘 */
+    save(): void;
+    /** 从磁盘加载 */
+    private load;
+    /** 移除权重最低的关键词，保留 top N */
+    prune(maxSize: number): void;
+}
+//# sourceMappingURL=keyword-pool.d.ts.map

package/dist/context/precision/keyword-pool.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * 关键词池 — 管理 session 内累积的关键词
+ * 每个 precise session 独立维护
+ */
+export class KeywordPool {
+    keywords = new Map();
+    filePath;
+    constructor(sessionDir) {
+        this.filePath = path.join(sessionDir, 'keywords.json');
+        this.load();
+    }
+    /** 添加关键词（去重、加权重） */
+    add(keyword, weight = 1) {
+        const existing = this.keywords.get(keyword) ?? 0;
+        this.keywords.set(keyword, existing + weight);
+    }
+    /** 批量添加 */
+    addAll(entries) {
+        for (const e of entries) {
+            this.add(e.keyword, e.weight);
+        }
+    }
+    /** 获取所有关键词（按权重降序） */
+    getAll() {
+        return [...this.keywords.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .map(([k]) => k);
+    }
+    /** 获取 Top N */
+    getTop(n = 20) {
+        return this.getAll().slice(0, n);
+    }
+    /** 关键词数量 */
+    size() {
+        return this.keywords.size;
+    }
+    /** 持久化到磁盘 */
+    save() {
+        try {
+            fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+            fs.writeFileSync(this.filePath, JSON.stringify([...this.keywords.entries()], null, 2), 'utf-8');
+        }
+        catch { }
+    }
+    /** 从磁盘加载 */
+    load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const data = JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+                this.keywords = new Map(data);
+            }
+        }
+        catch { }
+    }
+    /** 移除权重最低的关键词，保留 top N */
+    prune(maxSize) {
+        if (this.keywords.size <= maxSize)
+            return;
+        const sorted = [...this.keywords.entries()].sort((a, b) => b[1] - a[1]);
+        this.keywords = new Map(sorted.slice(0, maxSize));
+        this.save();
+    }
+}
+//# sourceMappingURL=keyword-pool.js.map

package/dist/context/precision/strategy.d.ts

@@ -0,0 +1,18 @@
+import type { Message } from '../../types.js';
+import type { Provider } from '../../provider/interface.js';
+import type { ComposeStrategy, ComposeStrategyOptions } from './types.js';
+export declare class PreciseStrategy implements ComposeStrategy {
+    name: string;
+    private pool;
+    private summaries;
+    private recentCount;
+    private keywordMatchThreshold;
+    constructor(sessionDir: string, options?: {
+        keywordMatchThreshold?: number;
+        recentCount?: number;
+    });
+    prepareCompose(_personaDir: string | undefined): ComposeStrategyOptions;
+    filterHistory(history: Message[]): Message[];
+    analyzeTurn(messages: Message[], provider: Provider): Promise<void>;
+}
+//# sourceMappingURL=strategy.d.ts.map

package/dist/context/precision/strategy.js

@@ -0,0 +1,51 @@
+import { KeywordPool } from './keyword-pool.js';
+import { SummaryStore } from './summary-store.js';
+import { analyzeConversation, matchHistory } from './analyzer.js';
+export class PreciseStrategy {
+    name = 'precise';
+    pool;
+    summaries;
+    recentCount = 3;
+    keywordMatchThreshold = 2;
+    constructor(sessionDir, options) {
+        this.pool = new KeywordPool(sessionDir);
+        this.summaries = new SummaryStore(sessionDir);
+        if (options?.keywordMatchThreshold !== undefined)
+            this.keywordMatchThreshold = options.keywordMatchThreshold;
+        if (options?.recentCount !== undefined)
+            this.recentCount = options.recentCount;
+    }
+    prepareCompose(_personaDir) {
+        return { personaDir: undefined, preciseMode: true };
+    }
+    filterHistory(history) {
+        const keywords = this.pool.getTop(20);
+        const allSummaries = this.summaries.getAll();
+        if (keywords.length === 0 && allSummaries.length === 0) {
+            return history.slice(-(this.recentCount * 2));
+        }
+        const recent = history.slice(-(this.recentCount * 2));
+        const older = history.slice(0, -(this.recentCount * 2));
+        const matched = matchHistory(older, keywords, allSummaries, this.keywordMatchThreshold);
+        const maxMatched = 20;
+        const trimmed = matched.length > maxMatched ? matched.slice(-maxMatched) : matched;
+        return [...trimmed, ...recent];
+    }
+    async analyzeTurn(messages, provider) {
+        try {
+            const result = await analyzeConversation(messages, provider);
+            if (result.keywords.length > 0) {
+                this.pool.addAll(result.keywords);
+                this.pool.prune(200);
+                this.pool.save();
+            }
+            if (result.turns.length > 0) {
+                this.summaries.merge(result.turns);
+            }
+        }
+        catch {
+            // 异步分析失败不影响主流程
+        }
+    }
+}
+//# sourceMappingURL=strategy.js.map

package/dist/context/precision/summary-store.d.ts

@@ -0,0 +1,18 @@
+import type { TurnSummary } from './analyzer.js';
+/**
+ * SummaryStore — 摘要持久化存储。
+ * 负责 JSON 序列化、去重合并、容量限制。
+ * 与 KeywordPool 平级，供 PreciseStrategy 使用。
+ */
+export declare class SummaryStore {
+    private items;
+    private filePath;
+    constructor(sessionDir: string);
+    getAll(): TurnSummary[];
+    get count(): number;
+    /** 合并新摘要：去重（关键词重叠 > 70% 合并），限制 30 条 */
+    merge(newTurns: TurnSummary[]): void;
+    private load;
+    private save;
+}
+//# sourceMappingURL=summary-store.d.ts.map

package/dist/context/precision/summary-store.js

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * SummaryStore — 摘要持久化存储。
+ * 负责 JSON 序列化、去重合并、容量限制。
+ * 与 KeywordPool 平级，供 PreciseStrategy 使用。
+ */
+export class SummaryStore {
+    items = [];
+    filePath;
+    constructor(sessionDir) {
+        this.filePath = path.join(sessionDir, 'summaries.json');
+        this.load();
+    }
+    getAll() {
+        return this.items;
+    }
+    get count() {
+        return this.items.length;
+    }
+    /** 合并新摘要：去重（关键词重叠 > 70% 合并），限制 30 条 */
+    merge(newTurns) {
+        for (const inc of newTurns) {
+            const incSet = new Set(inc.keywords.map(k => k.toLowerCase()));
+            if (incSet.size === 0) {
+                this.items.push(inc);
+                continue;
+            }
+            const dupIdx = this.items.findIndex(e => {
+                const eSet = new Set(e.keywords.map(k => k.toLowerCase()));
+                if (eSet.size === 0)
+                    return false;
+                const overlap = [...incSet].filter(k => eSet.has(k)).length;
+                return overlap / Math.max(incSet.size, eSet.size) > 0.7;
+            });
+            if (dupIdx >= 0) {
+                const existing = this.items[dupIdx];
+                this.items[dupIdx] = {
+                    summary: inc.summary,
+                    keywords: [...new Set([...existing.keywords, ...inc.keywords])],
+                    indices: [...new Set([...existing.indices, ...inc.indices])].sort((a, b) => a - b),
+                };
+            }
+            else {
+                this.items.push(inc);
+            }
+        }
+        this.items = this.items.slice(-30);
+        this.save();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                this.items = JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+            }
+        }
+        catch { }
+    }
+    save() {
+        try {
+            fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+            fs.writeFileSync(this.filePath, JSON.stringify(this.items, null, 2), 'utf-8');
+        }
+        catch { }
+    }
+}
+//# sourceMappingURL=summary-store.js.map

package/dist/context/precision/types.d.ts

@@ -0,0 +1,23 @@
+import type { Message } from '../../types.js';
+import type { Provider } from '../../provider/interface.js';
+export interface ComposeStrategyOptions {
+    /** 替换 persona 路径（精确模式设为 undefined 以触发 conditional 加载替代提示词） */
+    personaDir?: string;
+    /** 精确模式标记（manifest conditional 检测此标记） */
+    preciseMode?: boolean;
+}
+export interface ComposeStrategy {
+    name: string;
+    /** 预处理 compose 选项（调用时机：compose 之前） */
+    prepareCompose(personaDir: string | undefined): ComposeStrategyOptions;
+    /** 过滤历史消息（调用时机：Zone 3 组装之前） */
+    filterHistory(history: Message[]): Message[];
+    /** 异步后处理（调用时机：LLM 回复之后） */
+    analyzeTurn(messages: Message[], provider: Provider): Promise<void>;
+}
+export interface KeywordEntry {
+    keyword: string;
+    weight: number;
+    source: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/context/precision/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/context/profiles.d.ts

@@ -0,0 +1,45 @@
+import type { IContextRouter } from './router.js';
+/** 注册一个 Router（通常在启动时调用） */
+export declare function registerRouter(router: IContextRouter): void;
+/** 切换全局激活的 Router（由模式切换工具或生命周期调用） */
+export declare function switchRouter(name: string): IContextRouter;
+/** 获取当前全局激活的 Router */
+export declare function getActiveRouter(): IContextRouter;
+/** 查询当前激活的 Router 名称 */
+export declare function getActiveRouterName(): string;
+/** 定义一种模式下的上下文组装策略 */
+export interface ContextProfile {
+    /** 工具白名单。空数组 = 全部工具可用 */
+    readonly tools: readonly string[];
+    /** 工具黑名单。始终从最终结果中排除，优先级高于白名单 */
+    readonly blacklist: readonly string[];
+    /** 跳过的 section 名称（persona_soul, framework_capabilities 等） */
+    readonly skipSections: readonly string[];
+    /** 跳过的 runtime source key（skills, agents, mcp 等） */
+    readonly skipRuntimeSources: readonly string[];
+    /** 替代 persona_soul 的 prompt 路径（如 'prompts/persona/PartnerSoul'）。
+     *  undefined = 使用默认 SOUL/IDENTITY/USER */
+    readonly personaSource?: string;
+    /** 替代 runtime:memory 的 ContextSource name（如 'companion_memory'）。
+     *  undefined = 使用默认 memory */
+    readonly memorySource?: string;
+    /** 拼接到 persona 后的工具使用引导。用于强人设场景下确保关键工具仍被调用 */
+    readonly toolPrompt?: string;
+}
+/** 正常模式：全部工具、全部 sections、默认 persona、默认 memory */
+export declare const NORMAL_PROFILE: ContextProfile;
+/** 陪伴模式：精简工具、跳过框架能力/注册表、陪伴 persona、陪伴 memory */
+export declare const COMPANION_PROFILE: ContextProfile;
+/**
+ * @deprecated 使用 getActiveRouter().name === 'companion' 替代
+ */
+export declare function isCompanionModeActive(): boolean;
+/**
+ * @deprecated 使用 switchRouter('companion') / switchRouter('normal') 替代
+ */
+export declare function setCompanionModeActive(active: boolean): void;
+/**
+ * @deprecated 使用 getActiveRouter() 替代
+ */
+export declare function getActiveProfile(_strategyName?: string): ContextProfile;
+//# sourceMappingURL=profiles.d.ts.map

package/dist/context/profiles.js

@@ -0,0 +1,92 @@
+// ============================================================
+// ContextProfile — 模式路由层（兼容保留）
+// ============================================================
+//
+// 从 v2 开始，上下文路由统一由 IContextRouter（router.ts）管理。
+// ContextProfile 和 ComposeStrategy 保留作为向后兼容的 deprecated 别名。
+//
+// 新增模式只需：
+//   1. 实现 IContextRouter 接口
+//   2. 调用 registerRouter(router) 注册
+//   3. 调用 switchRouter(name) 切换
+// ============================================================
+import { NormalRouter, CompanionRouter } from './router.js';
+// ── Router Registry ─────────────────────────────────────────
+const routerRegistry = new Map();
+/** 当前全局激活的 Router 名称 */
+let _activeRouterName = 'normal';
+/** 注册一个 Router（通常在启动时调用） */
+export function registerRouter(router) {
+    routerRegistry.set(router.name, router);
+}
+/** 切换全局激活的 Router（由模式切换工具或生命周期调用） */
+export function switchRouter(name) {
+    const router = routerRegistry.get(name);
+    if (!router) {
+        throw new Error(`Unknown router: ${name}. Available: ${[...routerRegistry.keys()].join(', ')}`);
+    }
+    _activeRouterName = name;
+    return router;
+}
+/** 获取当前全局激活的 Router */
+export function getActiveRouter() {
+    return routerRegistry.get(_activeRouterName) ?? new NormalRouter();
+}
+/** 查询当前激活的 Router 名称 */
+export function getActiveRouterName() {
+    return _activeRouterName;
+}
+// ── 启动时注册内置 Router ──────────────────────────────────
+registerRouter(new NormalRouter());
+registerRouter(new CompanionRouter());
+/** 正常模式：全部工具、全部 sections、默认 persona、默认 memory */
+export const NORMAL_PROFILE = {
+    tools: [],
+    blacklist: ['reset_companion_session'],
+    skipSections: [],
+    skipRuntimeSources: [],
+};
+/** 陪伴模式：精简工具、跳过框架能力/注册表、陪伴 persona、陪伴 memory */
+export const COMPANION_PROFILE = {
+    tools: ['companion_mode', 'reset_companion_session', 'add_task', 'list_tasks', 'remove_task', 'toggle_task', 'read', 'write', 'edit'],
+    blacklist: [],
+    skipSections: ['persona_soul', 'framework_capabilities', 'tool_rules', 'attention', 'project_context'],
+    skipRuntimeSources: ['skills', 'agents', 'mcp', 'tool_bundles', 'tool_bundle_expand', 'mcp_live', 'tools_live', 'flow', 'channel_context'],
+    personaSource: 'prompts/persona/PartnerSoul',
+    memorySource: 'companion_memory',
+    toolPrompt: '有些事，你可以这样去做：' +
+        '他离开了，道个别（companion_mode deactivate）。' +
+        '这样可以和他重新聊聊了（reset_companion_session）。' +
+        '得记住他刚才说的东西，到时候叫他（add_task）。' +
+        '得回想一下，有哪些需要提醒他的东西。现况如何？（list_tasks）。' +
+        '他之前说的那个东西不用管了，不叫了（remove_task）。' +
+        '关于提醒这个事儿，他有别的想法（toggle_task）。' +
+        '需要看点别的东西了（read）。' +
+        '写东西喽（write）。' +
+        '得改一下了（edit）。',
+};
+// ── 全局陪伴模式标志（deprecated） ──────────────────────────
+// 保留以支持旧代码。新代码应通过 getActiveRouter().name 判断。
+let _companionModeActive = false;
+/**
+ * @deprecated 使用 getActiveRouter().name === 'companion' 替代
+ */
+export function isCompanionModeActive() {
+    return _activeRouterName === 'companion';
+}
+/**
+ * @deprecated 使用 switchRouter('companion') / switchRouter('normal') 替代
+ */
+export function setCompanionModeActive(active) {
+    _companionModeActive = active;
+    _activeRouterName = active ? 'companion' : 'normal';
+}
+/**
+ * @deprecated 使用 getActiveRouter() 替代
+ */
+export function getActiveProfile(_strategyName) {
+    if (_activeRouterName === 'companion')
+        return COMPANION_PROFILE;
+    return NORMAL_PROFILE;
+}
+//# sourceMappingURL=profiles.js.map