team-anya-cli 0.1.0

package/packages/mcp-tools/dist/layer1/memory-forget.js

@@ -0,0 +1,108 @@
+import { insertAuditEvent } from '@team-anya/db';
+import { readFile, writeFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import * as yaml from 'yaml';
+/**
+ * 遗忘/失效记忆（新增工具）
+ *
+ * 当前只实现 invalidate 模式：将匹配条目的 heat 设为 0。
+ * // TODO: 后续实现 decay（定时衰减）和 merge（合并相似记忆）模式
+ */
+export async function memoryForget(db, workspacePath, input) {
+    if (input.mode !== 'invalidate') {
+        throw new Error(`不支持的遗忘模式: ${input.mode}，当前仅支持 invalidate`);
+    }
+    const details = [];
+    let affectedCount = 0;
+    // 确定搜索范围
+    const memoryBase = join(workspacePath, 'memory');
+    const searchDir = input.scope
+        ? join(memoryBase, input.scope)
+        : memoryBase;
+    // 查找所有 yaml 文件
+    const yamlFiles = await findYamlFiles(searchDir);
+    for (const filePath of yamlFiles) {
+        try {
+            const content = await readFile(filePath, 'utf-8');
+            const doc = yaml.parse(content);
+            if (!doc)
+                continue;
+            // 获取条目列表
+            const listKey = doc.entries ? 'entries' : doc.observations ? 'observations' : doc.active ? 'active' : null;
+            if (!listKey || !Array.isArray(doc[listKey]))
+                continue;
+            let changed = false;
+            for (const entry of doc[listKey]) {
+                if (!input.target) {
+                    // 无 target：失效所有条目
+                    if (entry.meta) {
+                        entry.meta.heat = 0;
+                        changed = true;
+                        affectedCount++;
+                    }
+                }
+                else {
+                    // 有 target：匹配内容关键词
+                    const entryContent = typeof entry === 'string' ? entry : (entry.content ?? '');
+                    if (entryContent.includes(input.target)) {
+                        if (entry.meta) {
+                            entry.meta.heat = 0;
+                        }
+                        else {
+                            entry.meta = { heat: 0 };
+                        }
+                        changed = true;
+                        affectedCount++;
+                        details.push(`已失效: ${entryContent.slice(0, 80)}`);
+                    }
+                }
+            }
+            if (changed) {
+                await writeFile(filePath, yaml.stringify(doc), 'utf-8');
+            }
+        }
+        catch {
+            // 文件处理失败，继续下一个
+        }
+    }
+    // 写审计事件
+    try {
+        insertAuditEvent(db, {
+            event_type: 'memory_invalidated',
+            actor: 'system',
+            task_id: null,
+            summary: `记忆失效: scope=${input.scope ?? 'all'}, target=${input.target ?? 'all'}, affected=${affectedCount}`,
+            detail: JSON.stringify({
+                mode: input.mode,
+                scope: input.scope,
+                target: input.target,
+                reason: input.reason,
+                affected_count: affectedCount,
+            }),
+        });
+    }
+    catch {
+        // 审计失败不阻塞
+    }
+    return {
+        success: true,
+        affected_count: affectedCount,
+        details,
+    };
+}
+async function findYamlFiles(dir) {
+    const files = [];
+    try {
+        const entries = await readdir(dir, { withFileTypes: true, recursive: true });
+        for (const entry of entries) {
+            if (entry.isFile() && (entry.name.endsWith('.yaml') || entry.name.endsWith('.yml'))) {
+                files.push(join(entry.parentPath, entry.name));
+            }
+        }
+    }
+    catch {
+        // 目录不存在
+    }
+    return files;
+}
+//# sourceMappingURL=memory-forget.js.map

package/packages/mcp-tools/dist/layer1/memory-learn.js

@@ -0,0 +1,63 @@
+import { insertAuditEvent } from '@team-anya/db';
+import { appendFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+const VALID_TYPES = ['task', 'decision', 'failure', 'project', 'org', 'insight', 'commitment', 'opportunity'];
+/**
+ * 主动写入记忆
+ *
+ * 写入 DB memories 表 + 审计事件。
+ * 替代原有的 memory-write（纯文件模式），改为结构化存储。
+ *
+ * 降级策略：DB 尚无 memories 表时，降级写入 memory/ 目录的文件 + 审计事件。
+ */
+export async function memoryLearn(db, workspacePath, input) {
+    // 校验 type
+    if (!VALID_TYPES.includes(input.type)) {
+        throw new Error(`无效的记忆类型: ${input.type}，有效值: ${VALID_TYPES.join(', ')}`);
+    }
+    // 校验 tags
+    if (!input.tags || input.tags.length < 1) {
+        throw new Error('至少需要 1 个 tag');
+    }
+    const importance = input.importance ?? 0.5;
+    if (importance < 0 || importance > 1) {
+        throw new Error('importance 必须在 0-1 之间');
+    }
+    // 降级策略：写文件 + 审计事件
+    // 当 memories 表就绪后，这里改为 DB 写入
+    const memoryDir = join(workspacePath, 'memory', input.type === 'project' && input.project_id
+        ? `projects/${input.project_id}`
+        : input.type === 'decision' ? 'decisions'
+            : input.type === 'org' ? 'org'
+                : 'self');
+    await mkdir(memoryDir, { recursive: true });
+    const timestamp = new Date().toISOString();
+    const fileName = `${input.type}-${timestamp.slice(0, 10)}.md`;
+    const filePath = join(memoryDir, fileName);
+    const header = [
+        `<!-- type: ${input.type} -->`,
+        `<!-- tags: ${input.tags.join(', ')} -->`,
+        `<!-- importance: ${importance} -->`,
+        input.task_id ? `<!-- task: ${input.task_id} -->` : '',
+        input.project_id ? `<!-- project: ${input.project_id} -->` : '',
+        input.expires_at ? `<!-- expires: ${input.expires_at} -->` : '',
+        `<!-- created: ${timestamp} -->`,
+        '',
+    ].filter(Boolean).join('\n');
+    await appendFile(filePath, `\n${header}\n${input.content}\n\n---\n`);
+    // 写审计事件
+    const result = insertAuditEvent(db, {
+        event_type: 'memory_learned',
+        actor: 'system',
+        task_id: input.task_id ?? null,
+        summary: `记忆沉淀 [${input.type}]: ${input.content.slice(0, 100)}`,
+        detail: JSON.stringify({
+            tags: input.tags,
+            importance,
+            project_id: input.project_id,
+            expires_at: input.expires_at,
+        }),
+    });
+    return { success: true, memory_id: result.id };
+}
+//# sourceMappingURL=memory-learn.js.map

package/packages/mcp-tools/dist/layer1/memory-recall.js

@@ -0,0 +1,287 @@
+import { readFile, readdir, writeFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import * as yaml from 'yaml';
+/**
+ * 召回记忆（替代 memory.search）
+ *
+ * - person 参数 → 直接读 memory/people/{person}.yaml
+ * - project 参数 → 读 memory/projects/{project}/ 下所有 yaml
+ * - 无特定 scope → BM25 搜索所有 memory 子目录
+ * - 每次召回命中的条目，更新 meta.last_accessed 和 meta.access_count
+ */
+export async function memoryRecall(workspacePath, input) {
+    const limit = input.limit ?? 5;
+    const depth = input.depth ?? 'summary';
+    // 快捷方式：person → scope
+    if (input.person) {
+        const results = await recallPerson(workspacePath, input.person, depth);
+        return { results: results.slice(0, limit) };
+    }
+    // 快捷方式：project → scope
+    if (input.project) {
+        const results = await recallProject(workspacePath, input.project, depth, input.query);
+        return { results: results.slice(0, limit) };
+    }
+    // scope 限定搜索
+    if (input.scope && input.scope.length > 0) {
+        const results = [];
+        for (const s of input.scope) {
+            const scopeResults = await searchScope(workspacePath, s, input.query, depth);
+            results.push(...scopeResults);
+        }
+        results.sort((a, b) => b.relevance - a.relevance);
+        return { results: results.slice(0, limit) };
+    }
+    // 全局 BM25 搜索
+    const results = await globalSearch(workspacePath, input.query, depth);
+    results.sort((a, b) => b.relevance - a.relevance);
+    return { results: results.slice(0, limit) };
+}
+// ── 按人召回 ──
+async function recallPerson(workspacePath, person, depth) {
+    const filePath = join(workspacePath, 'memory', 'people', `${person}.yaml`);
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        const doc = yaml.parse(content);
+        if (!doc)
+            return [];
+        await updateAccessMeta(filePath, content, doc, 'observations');
+        if (depth === 'summary') {
+            // 返回最近 3 条 observations 的摘要
+            const observations = (doc.observations ?? []).slice(-3);
+            return observations.map((o) => ({
+                content: typeof o === 'string' ? o : (o.content ?? JSON.stringify(o)),
+                source: `memory/people/${person}.yaml`,
+                relevance: 1.0,
+                category: 'people',
+            }));
+        }
+        // full: 返回所有 observations
+        return (doc.observations ?? []).map((o) => ({
+            content: typeof o === 'string' ? o : (o.content ?? JSON.stringify(o)),
+            source: `memory/people/${person}.yaml`,
+            relevance: 1.0,
+            category: 'people',
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+// ── 按项目召回 ──
+async function recallProject(workspacePath, project, depth, query) {
+    const projectDir = join(workspacePath, 'memory', 'projects', project);
+    const results = [];
+    try {
+        const files = await findYamlFiles(projectDir);
+        for (const file of files) {
+            const fileResults = await searchYamlFile(file, workspacePath, query, 'project', depth);
+            results.push(...fileResults);
+        }
+    }
+    catch {
+        // 目录不存在
+    }
+    results.sort((a, b) => b.relevance - a.relevance);
+    return results;
+}
+// ── 按 scope 搜索 ──
+async function searchScope(workspacePath, scope, query, depth) {
+    const scopeDir = join(workspacePath, 'memory', scope);
+    const results = [];
+    const category = scope.split('/')[0];
+    try {
+        const files = await findYamlAndMdFiles(scopeDir);
+        for (const file of files) {
+            if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+                const fileResults = await searchYamlFile(file, workspacePath, query, category, depth);
+                results.push(...fileResults);
+            }
+            else if (file.endsWith('.md')) {
+                const fileResults = await searchMdFile(file, workspacePath, query, category);
+                results.push(...fileResults);
+            }
+        }
+    }
+    catch {
+        // 目录不存在
+    }
+    return results;
+}
+// ── 全局搜索 ──
+async function globalSearch(workspacePath, query, depth) {
+    const results = [];
+    const dirs = ['people', 'projects', 'execution', 'commitments', 'self'];
+    for (const dir of dirs) {
+        const dirPath = join(workspacePath, 'memory', dir);
+        try {
+            const files = await findYamlAndMdFiles(dirPath);
+            for (const file of files) {
+                if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+                    const fileResults = await searchYamlFile(file, workspacePath, query, dir, depth);
+                    results.push(...fileResults);
+                }
+                else if (file.endsWith('.md')) {
+                    const fileResults = await searchMdFile(file, workspacePath, query, dir);
+                    results.push(...fileResults);
+                }
+            }
+        }
+        catch {
+            // 目录不存在，继续
+        }
+    }
+    return results;
+}
+// ── YAML 文件搜索 ──
+async function searchYamlFile(filePath, workspacePath, query, category, depth) {
+    const results = [];
+    const relPath = relative(workspacePath, filePath);
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        const doc = yaml.parse(content);
+        if (!doc)
+            return [];
+        // 获取条目列表（可能是 entries、observations 或 active）
+        const entries = doc.entries ?? doc.observations ?? doc.active ?? [];
+        if (!Array.isArray(entries))
+            return [];
+        const queryTerms = tokenize(query);
+        let hasHit = false;
+        for (const entry of entries) {
+            const entryContent = typeof entry === 'string' ? entry : (entry.content ?? '');
+            const relevance = computeRelevance(entryContent, queryTerms);
+            if (relevance > 0) {
+                hasHit = true;
+                // 检查 heat：heat 为 0 的条目跳过
+                if (entry.meta?.heat === 0)
+                    continue;
+                results.push({
+                    content: depth === 'summary' ? entryContent.slice(0, 200) : entryContent,
+                    source: relPath,
+                    relevance,
+                    category,
+                });
+            }
+        }
+        // 更新 access meta（如果有命中）
+        if (hasHit) {
+            await updateAccessMeta(filePath, content, doc, doc.entries ? 'entries' : doc.observations ? 'observations' : 'active');
+        }
+    }
+    catch {
+        // 文件读取失败
+    }
+    return results;
+}
+// ── Markdown 文件搜索（向后兼容） ──
+async function searchMdFile(filePath, workspacePath, query, category) {
+    const results = [];
+    const relPath = relative(workspacePath, filePath);
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        const paragraphs = content.split(/\n(?=##?\s)|\n{2,}/).filter(p => p.trim().length > 20);
+        const queryTerms = tokenize(query);
+        for (const paragraph of paragraphs) {
+            const relevance = computeRelevance(paragraph, queryTerms);
+            if (relevance > 0) {
+                results.push({
+                    content: paragraph.trim().slice(0, 200),
+                    source: relPath,
+                    relevance,
+                    category,
+                });
+            }
+        }
+    }
+    catch {
+        // 文件读取失败
+    }
+    return results;
+}
+// ── 工具函数 ──
+function tokenize(text) {
+    const tokens = [];
+    const lower = text.toLowerCase();
+    // 英文词
+    const englishWords = lower.match(/[a-z0-9_]+/g) || [];
+    for (const word of englishWords) {
+        if (word.length > 1)
+            tokens.push(word);
+    }
+    // 中文 bigram
+    const chineseSegments = lower.match(/[\u4e00-\u9fff]+/g) || [];
+    for (const segment of chineseSegments) {
+        for (const char of segment)
+            tokens.push(char);
+        for (let i = 0; i < segment.length - 1; i++) {
+            tokens.push(segment.slice(i, i + 2));
+        }
+    }
+    return tokens;
+}
+function computeRelevance(text, queryTerms) {
+    if (queryTerms.length === 0)
+        return 0;
+    const lower = text.toLowerCase();
+    const textTokens = new Set(tokenize(lower));
+    let hits = 0;
+    for (const term of queryTerms) {
+        if (textTokens.has(term) || lower.includes(term))
+            hits++;
+    }
+    return hits / queryTerms.length;
+}
+async function updateAccessMeta(filePath, _rawContent, doc, listKey) {
+    try {
+        const entries = doc[listKey];
+        if (!Array.isArray(entries))
+            return;
+        let changed = false;
+        const now = new Date().toISOString();
+        for (const entry of entries) {
+            if (entry?.meta) {
+                entry.meta.last_accessed = now;
+                entry.meta.access_count = (entry.meta.access_count ?? 0) + 1;
+                changed = true;
+            }
+        }
+        if (changed) {
+            await writeFile(filePath, yaml.stringify(doc), 'utf-8');
+        }
+    }
+    catch {
+        // 更新失败不阻塞
+    }
+}
+async function findYamlFiles(dir) {
+    const files = [];
+    try {
+        const entries = await readdir(dir, { withFileTypes: true, recursive: true });
+        for (const entry of entries) {
+            if (entry.isFile() && (entry.name.endsWith('.yaml') || entry.name.endsWith('.yml'))) {
+                files.push(join(entry.parentPath, entry.name));
+            }
+        }
+    }
+    catch {
+        // 目录不存在
+    }
+    return files;
+}
+async function findYamlAndMdFiles(dir) {
+    const files = [];
+    try {
+        const entries = await readdir(dir, { withFileTypes: true, recursive: true });
+        for (const entry of entries) {
+            if (entry.isFile() && (entry.name.endsWith('.yaml') || entry.name.endsWith('.yml') || entry.name.endsWith('.md'))) {
+                files.push(join(entry.parentPath, entry.name));
+            }
+        }
+    }
+    catch {
+        // 目录不存在
+    }
+    return files;
+}
+//# sourceMappingURL=memory-recall.js.map

package/packages/mcp-tools/dist/layer1/memory-reflect.js

@@ -0,0 +1,80 @@
+import { getAuditEventsByTask } from '@team-anya/db';
+import { memoryLearn } from './memory-learn.js';
+/**
+ * 触发 LLM 反思，从最近事件中提取长期记忆
+ *
+ * 当前实现：用基于规则的提取代替 LLM 调用。
+ * 提取规则：
+ * 1. 失败事件 → failure 记忆（高 importance）
+ * 2. 决策事件 → decision 记忆
+ * 3. 阻塞事件 → insight 记忆
+ *
+ * 后续升级：调用小模型（Haiku）做更精确的反思提取。
+ */
+export async function memoryReflect(db, workspacePath, input) {
+    const entries = [];
+    // 收集事件源
+    let eventSummaries = [];
+    if (input.task_id) {
+        const events = getAuditEventsByTask(db, input.task_id);
+        eventSummaries = events.map(e => `[${e.event_type}] ${e.summary}`);
+    }
+    if (input.recent_events) {
+        eventSummaries.push(...input.recent_events.split('\n').filter(l => l.trim()));
+    }
+    if (eventSummaries.length === 0) {
+        return { memories_created: 0, entries: [] };
+    }
+    // 基于规则提取记忆
+    for (const summary of eventSummaries) {
+        const lower = summary.toLowerCase();
+        if (lower.includes('fail') || lower.includes('失败') || lower.includes('error')) {
+            entries.push({
+                content: `失败记录: ${summary}`,
+                type: 'failure',
+                tags: ['auto-reflect', 'failure'],
+                importance: 0.8,
+            });
+        }
+        else if (lower.includes('decision') || lower.includes('决策')) {
+            entries.push({
+                content: `决策记录: ${summary}`,
+                type: 'decision',
+                tags: ['auto-reflect', 'decision'],
+                importance: 0.6,
+            });
+        }
+        else if (lower.includes('block') || lower.includes('阻塞') || lower.includes('卡住')) {
+            entries.push({
+                content: `阻塞经验: ${summary}`,
+                type: 'insight',
+                tags: ['auto-reflect', 'blocker'],
+                importance: 0.7,
+            });
+        }
+    }
+    // 去重（避免同一事件重复写入）
+    const seen = new Set();
+    const uniqueEntries = entries.filter(e => {
+        const key = `${e.type}:${e.content.slice(0, 50)}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    // 写入记忆
+    for (const entry of uniqueEntries) {
+        await memoryLearn(db, workspacePath, {
+            content: entry.content,
+            type: entry.type,
+            tags: entry.tags,
+            importance: entry.importance,
+            task_id: input.task_id,
+        });
+    }
+    return {
+        memories_created: uniqueEntries.length,
+        entries: uniqueEntries,
+    };
+}
+//# sourceMappingURL=memory-reflect.js.map

package/packages/mcp-tools/dist/layer1/memory-remember.js

@@ -0,0 +1,119 @@
+import { insertAuditEvent } from '@team-anya/db';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import * as yaml from 'yaml';
+// 按 category 自动设置默认衰减率
+const DEFAULT_DECAY_RATES = {
+    people: 0.01, // 人的记忆衰减很慢
+    project: 0.05, // 项目经验中等衰减
+    execution: 0.1, // 执行经验衰减较快
+    commitment: 0.2, // 承诺衰减快（需要定期刷新）
+    self: 0.02, // 自我认知衰减很慢
+};
+/**
+ * 写入记忆（替代 memory.learn）
+ *
+ * 按 category + target 映射到 YAML 文件路径，支持追加和创建。
+ * 每条记忆带 meta（created_at, heat, decay_rate, access_count, last_accessed）。
+ */
+export async function memoryRemember(db, workspacePath, input) {
+    const importance = input.importance ?? 0.5;
+    if (importance < 0 || importance > 1) {
+        throw new Error('importance 必须在 0-1 之间');
+    }
+    const filePath = resolveFilePath(workspacePath, input);
+    await mkdir(dirname(filePath), { recursive: true });
+    const now = new Date().toISOString();
+    const newEntry = {
+        content: input.content,
+        meta: {
+            created_at: now,
+            heat: 1.0,
+            decay_rate: DEFAULT_DECAY_RATES[input.category] ?? 0.05,
+            access_count: 0,
+            last_accessed: now,
+            importance,
+            ...(input.source ? { source: input.source } : {}),
+            ...(input.expires_at ? { expires_at: input.expires_at } : {}),
+        },
+    };
+    let entries = [];
+    let doc = {};
+    // 读取已有文件
+    try {
+        const existing = await readFile(filePath, 'utf-8');
+        doc = yaml.parse(existing) ?? {};
+    }
+    catch {
+        // 文件不存在，创建新的
+    }
+    if (input.category === 'people') {
+        // people 类型特殊处理：追加到 observations 列表
+        if (!doc.id)
+            doc.id = input.target;
+        if (!doc.observations)
+            doc.observations = [];
+        doc.observations.push(newEntry);
+        entries = doc.observations;
+    }
+    else if (input.category === 'commitment') {
+        // commitment：追加到 active 列表
+        if (!doc.active)
+            doc.active = [];
+        doc.active.push(newEntry);
+        entries = doc.active;
+    }
+    else {
+        // 其他类型：追加到 entries 列表
+        if (!doc.entries)
+            doc.entries = [];
+        doc.entries.push(newEntry);
+        entries = doc.entries;
+    }
+    await writeFile(filePath, yaml.stringify(doc), 'utf-8');
+    // 写审计事件
+    try {
+        insertAuditEvent(db, {
+            event_type: 'memory_remembered',
+            actor: 'system',
+            task_id: input.source ?? null,
+            summary: `记忆写入 [${input.category}${input.target ? '/' + input.target : ''}]: ${input.content.slice(0, 100)}`,
+            detail: JSON.stringify({
+                category: input.category,
+                target: input.target,
+                sub_type: input.sub_type,
+                importance,
+            }),
+        });
+    }
+    catch {
+        // 审计失败不阻塞主流程
+    }
+    const relPath = filePath.replace(workspacePath + '/', '');
+    return { success: true, path: relPath, entry_count: entries.length };
+}
+/**
+ * 根据 category + target 映射到文件路径
+ */
+function resolveFilePath(workspacePath, input) {
+    const memoryBase = join(workspacePath, 'memory');
+    switch (input.category) {
+        case 'people':
+            if (!input.target)
+                throw new Error('people 类型必须指定 target (sender_id)');
+            return join(memoryBase, 'people', `${input.target}.yaml`);
+        case 'project':
+            if (!input.target)
+                throw new Error('project 类型必须指定 target (project_id)');
+            return join(memoryBase, 'projects', input.target, `${input.sub_type || 'general'}.yaml`);
+        case 'execution':
+            return join(memoryBase, 'execution', `${input.sub_type || 'general'}.yaml`);
+        case 'commitment':
+            return join(memoryBase, 'commitments', 'active.yaml');
+        case 'self':
+            return join(memoryBase, 'self', 'profile.yaml');
+        default:
+            throw new Error(`未知记忆类别: ${input.category}`);
+    }
+}
+//# sourceMappingURL=memory-remember.js.map