team-anya-cli 0.1.0

package/packages/db/src/migrations/meta/_journal.json

@@ -0,0 +1,41 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1771231965763,
+      "tag": "0000_simple_magneto",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "6",
+      "when": 1771898136519,
+      "tag": "0001_nifty_morph",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "6",
+      "when": 1771903810417,
+      "tag": "0002_common_joshua_kane",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "6",
+      "when": 1772006400000,
+      "tag": "0003_add_cc_sessions",
+      "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "6",
+      "when": 1771937237299,
+      "tag": "0004_jittery_triathlon",
+      "breakpoints": true
+    }
+  ]
+}

package/packages/mcp-tools/dist/index.js

@@ -0,0 +1,41 @@
+// ── Layer 1: 共享基础 — 记忆工具（v2） ──
+export { memoryRecall } from './layer1/memory-recall.js';
+export { memoryRemember } from './layer1/memory-remember.js';
+export { memoryDigest } from './layer1/memory-digest.js';
+export { memoryBrief } from './layer1/memory-brief.js';
+export { memoryForget } from './layer1/memory-forget.js';
+// ── Layer 1: 旧版记忆工具（deprecated，保留编译兼容） ──
+/** @deprecated 使用 memoryBrief 替代 */
+export { memoryContext } from './layer1/memory-context.js';
+/** @deprecated 使用 memoryRecall 替代 */
+export { memorySearch, buildSearchIndex } from './layer1/memory-search.js';
+/** @deprecated 使用 memoryRemember 替代 */
+export { memoryLearn } from './layer1/memory-learn.js';
+/** @deprecated 使用 memoryDigest 替代 */
+export { memoryReflect } from './layer1/memory-reflect.js';
+export { orgLookup } from './layer1/org-lookup.js';
+export { taskGet } from './layer1/task-get.js';
+export { auditAppend, appendToAuditFile } from './layer1/audit-append.js';
+export { auditQuery } from './layer1/audit-query.js';
+export { reportDaily } from './layer1/report-daily.js';
+// ── Layer 2: Loid 专属 ──
+export { taskDispatch } from './layer2/loid/task-dispatch.js';
+export { taskLookup } from './layer2/loid/task-lookup.js';
+export { decisionLog } from './layer2/loid/decision-log.js';
+// ── Layer 2: Yor 专属 ──
+export { taskDeliver } from './layer2/yor/task-deliver.js';
+export { taskBlock } from './layer2/yor/task-block.js';
+export { taskProgress } from './layer2/yor/task-progress.js';
+// ── Layer 3: 外部桥梁 ──
+export { channelSend } from './layer3/channel-send.js';
+export { channelReceive } from './layer3/channel-receive.js';
+export { fileUpload } from './layer3/file-upload.js';
+export { ChannelRegistry } from './layer3/adapters/types.js';
+export { FeishuAdapter, detectMediaKind, resolveFileType, isMarkdown } from './layer3/adapters/feishu-adapter.js';
+// ── Registry ──
+export { createToolRouter, getToolsForRole, TOOL_REGISTRY } from './registry.js';
+// ── 向后兼容（旧导出名保留） ──
+export { taskGet as taskContext } from './layer1/task-get.js';
+/** @deprecated 使用 memoryLearn 替代 */
+export { memoryWrite } from './layer1/memory-write.js';
+//# sourceMappingURL=index.js.map

package/packages/mcp-tools/dist/layer1/audit-append.js

@@ -0,0 +1,38 @@
+import { appendFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { insertAuditEvent } from '@team-anya/db';
+/**
+ * 审计事件双写：SQLite + 文件
+ */
+export async function auditAppend(db, workspacePath, input) {
+    // 1. 写入 SQLite
+    const result = insertAuditEvent(db, {
+        event_type: input.event_type,
+        actor: input.actor,
+        task_id: input.task_id ?? null,
+        summary: input.summary,
+        detail: input.detail ? JSON.stringify(input.detail) : null,
+    });
+    // 2. 写入审计文件
+    await appendToAuditFile(workspacePath, input);
+    return { event_id: result.id };
+}
+/**
+ * 仅写审计文件（taskTransition 内部调用）
+ */
+export async function appendToAuditFile(workspacePath, input) {
+    const date = new Date().toISOString().slice(0, 10);
+    const auditDir = join(workspacePath, 'audit');
+    await mkdir(auditDir, { recursive: true });
+    const filePath = join(auditDir, `events-${date}.jsonl`);
+    const entry = {
+        ts: new Date().toISOString(),
+        type: input.event_type,
+        actor: input.actor,
+        task_id: input.task_id,
+        summary: input.summary,
+        ...(input.detail ? { detail: input.detail } : {}),
+    };
+    await appendFile(filePath, JSON.stringify(entry) + '\n');
+}
+//# sourceMappingURL=audit-append.js.map

package/packages/mcp-tools/dist/layer1/audit-query.js

@@ -0,0 +1,51 @@
+import { getAuditEventsByTask, getAuditEventsByType, getAuditEventsByDate } from '@team-anya/db';
+/**
+ * 查询审计事件
+ *
+ * 支持按 task_id、event_type、actor、时间范围过滤。
+ * 补齐"只写不读"的缺陷。
+ */
+export async function auditQuery(db, input) {
+    const limit = input.limit ?? 20;
+    let events;
+    // 按优先级选择查询路径
+    if (input.task_id) {
+        events = getAuditEventsByTask(db, input.task_id);
+    }
+    else if (input.event_type) {
+        events = getAuditEventsByType(db, input.event_type);
+    }
+    else if (input.since) {
+        // 按日期查询（取 since 的日期部分）
+        const date = input.since.slice(0, 10);
+        events = getAuditEventsByDate(db, date);
+    }
+    else {
+        // 无过滤条件时，查今天的事件
+        const today = new Date().toISOString().slice(0, 10);
+        events = getAuditEventsByDate(db, today);
+    }
+    // 应用 actor 过滤
+    if (input.actor) {
+        events = events.filter(e => e.actor === input.actor);
+    }
+    // 应用 since 时间过滤
+    if (input.since) {
+        const sinceTime = new Date(input.since).getTime();
+        events = events.filter(e => new Date(e.created_at).getTime() >= sinceTime);
+    }
+    // 按时间倒序，截取 limit
+    events.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+    return {
+        events: events.slice(0, limit).map(e => ({
+            id: e.id,
+            event_type: e.event_type,
+            actor: e.actor,
+            task_id: e.task_id,
+            summary: e.summary,
+            detail: e.detail,
+            created_at: e.created_at,
+        })),
+    };
+}
+//# sourceMappingURL=audit-query.js.map

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

@@ -0,0 +1,168 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import * as yaml from 'yaml';
+import { memoryRecall } from './memory-recall.js';
+// 1 token ~ 3 characters（中英混合粗估）
+const CHARS_PER_TOKEN = 3;
+/**
+ * 组装记忆摘要（替代 memory.context）
+ *
+ * 按优先级在 token 预算内组装记忆：
+ * 1. 人的记忆
+ * 2. 项目注意事项
+ * 3. 相关执行经验
+ * 4. 活跃承诺
+ * 5. 自我提醒
+ */
+export async function memoryBrief(workspacePath, input) {
+    const tokenBudget = input.token_budget ?? 1500;
+    const maxChars = tokenBudget * CHARS_PER_TOKEN;
+    const sections = [];
+    const sources = [];
+    let charsUsed = 0;
+    const appendSection = (label, content, count) => {
+        const sectionText = `### ${label}\n${content}`;
+        if (charsUsed + sectionText.length > maxChars) {
+            const remaining = maxChars - charsUsed;
+            if (remaining > 50) {
+                sections.push(`### ${label}\n${content.slice(0, remaining - label.length - 10)}...(截断)`);
+                sources.push({ label, count });
+                charsUsed = maxChars;
+            }
+            return false;
+        }
+        sections.push(sectionText);
+        sources.push({ label, count });
+        charsUsed += sectionText.length;
+        return true;
+    };
+    // 1. 人的记忆
+    if (input.sender_id) {
+        const personContent = await readPersonSummary(workspacePath, input.sender_id);
+        if (personContent) {
+            appendSection(`关于 ${input.sender_id}`, personContent, 1);
+        }
+    }
+    // 2. 项目注意事项
+    if (input.project_id) {
+        const pitfalls = await readProjectPitfalls(workspacePath, input.project_id);
+        if (pitfalls) {
+            appendSection(`${input.project_id} 注意事项`, pitfalls, 1);
+        }
+    }
+    // 3. 相关执行经验（BM25 搜索）
+    if (input.task_type || input.project_id) {
+        const query = [input.task_type, input.project_id].filter(Boolean).join(' ');
+        if (query) {
+            const result = await memoryRecall(workspacePath, {
+                query,
+                scope: ['execution'],
+                depth: 'summary',
+                limit: 3,
+            });
+            if (result.results.length > 0) {
+                const content = result.results.map(r => `- ${r.content}`).join('\n');
+                appendSection('执行经验', content, result.results.length);
+            }
+        }
+    }
+    // 4. 活跃承诺
+    if (input.sender_id) {
+        const commitments = await readActiveCommitments(workspacePath, input.sender_id);
+        if (commitments) {
+            appendSection('相关承诺', commitments, 1);
+        }
+    }
+    // 5. 自我提醒
+    const selfReminders = await readSelfReminders(workspacePath, input.task_type);
+    if (selfReminders) {
+        appendSection('自我提醒', selfReminders, 1);
+    }
+    const brief = sections.length > 0
+        ? `## 记忆摘要\n\n${sections.join('\n\n')}`
+        : '';
+    return {
+        brief,
+        sources,
+        budget_used: Math.ceil(charsUsed / CHARS_PER_TOKEN),
+    };
+}
+// ── 内部读取函数 ──
+async function readPersonSummary(workspacePath, personId) {
+    try {
+        const filePath = join(workspacePath, 'memory', 'people', `${personId}.yaml`);
+        const content = await readFile(filePath, 'utf-8');
+        const doc = yaml.parse(content);
+        if (!doc?.observations)
+            return null;
+        // 取最近 3 条
+        const recent = doc.observations.slice(-3);
+        return recent.map((o) => `- ${typeof o === 'string' ? o : (o.content ?? '')}`).join('\n');
+    }
+    catch {
+        return null;
+    }
+}
+async function readProjectPitfalls(workspacePath, projectId) {
+    try {
+        const filePath = join(workspacePath, 'memory', 'projects', projectId, 'pitfall.yaml');
+        const content = await readFile(filePath, 'utf-8');
+        const doc = yaml.parse(content);
+        if (!doc?.entries)
+            return null;
+        // 只取 heat > 0 的活跃条目
+        const active = doc.entries.filter((e) => !e.meta || e.meta.heat > 0);
+        const recent = active.slice(-5);
+        return recent.map((e) => `- ${typeof e === 'string' ? e : (e.content ?? '')}`).join('\n');
+    }
+    catch {
+        return null;
+    }
+}
+async function readActiveCommitments(workspacePath, senderId) {
+    try {
+        const filePath = join(workspacePath, 'memory', 'commitments', 'active.yaml');
+        const content = await readFile(filePath, 'utf-8');
+        const doc = yaml.parse(content);
+        if (!doc?.active)
+            return null;
+        // 过滤与 senderId 相关的承诺
+        const related = doc.active.filter((c) => {
+            const text = typeof c === 'string' ? c : (c.content ?? '');
+            return text.includes(senderId);
+        });
+        if (related.length === 0)
+            return null;
+        return related.map((c) => `- ${typeof c === 'string' ? c : (c.content ?? '')}`).join('\n');
+    }
+    catch {
+        return null;
+    }
+}
+async function readSelfReminders(workspacePath, taskType) {
+    try {
+        const filePath = join(workspacePath, 'memory', 'self', 'profile.yaml');
+        const content = await readFile(filePath, 'utf-8');
+        const doc = yaml.parse(content);
+        if (!doc?.entries)
+            return null;
+        let entries = doc.entries.filter((e) => !e.meta || e.meta.heat > 0);
+        // 如果有 taskType，优先匹配相关条目
+        if (taskType) {
+            const related = entries.filter((e) => {
+                const text = typeof e === 'string' ? e : (e.content ?? '');
+                return text.toLowerCase().includes(taskType.toLowerCase());
+            });
+            if (related.length > 0)
+                entries = related;
+        }
+        const recent = entries.slice(-3);
+        if (recent.length === 0)
+            return null;
+        return recent.map((e) => `- ${typeof e === 'string' ? e : (e.content ?? '')}`).join('\n');
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=memory-brief.js.map

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

@@ -0,0 +1,124 @@
+import { getTask, getAuditEventsByTask, getActiveCommitments, getOpenOpportunities, getAllTasks } from '@team-anya/db';
+import { memorySearch } from './memory-search.js';
+import { orgLookup } from './org-lookup.js';
+// Token 预算（按字符数粗估，1 token ≈ 2 中文字符 / 4 英文字符）
+const TOKEN_BUDGET = 4000;
+/**
+ * 按场景获取预组装上下文
+ *
+ * 根据不同场景，按 required → recommended 顺序查询多种记忆源，
+ * 在 token 预算内拼装结构化文本供 Agent prompt 注入。
+ */
+export async function memoryContext(db, workspacePath, input) {
+    const sources = [];
+    const sections = [];
+    let budgetUsed = 0;
+    const appendSection = (label, content, count) => {
+        const estimatedTokens = Math.ceil(content.length / 3);
+        if (budgetUsed + estimatedTokens > TOKEN_BUDGET) {
+            // 截断到预算
+            const remaining = (TOKEN_BUDGET - budgetUsed) * 3;
+            if (remaining > 100) {
+                sections.push(`## ${label}\n${content.slice(0, remaining)}…(已截断)`);
+                sources.push({ label, count });
+                budgetUsed = TOKEN_BUDGET;
+            }
+            return;
+        }
+        sections.push(`## ${label}\n${content}`);
+        sources.push({ label, count });
+        budgetUsed += estimatedTokens;
+    };
+    switch (input.scene) {
+        case 'task_execution': {
+            // 为 Yor 执行任务提供上下文
+            const taskId = input.vars.current_task;
+            if (taskId) {
+                const task = getTask(db, taskId);
+                if (task) {
+                    appendSection('当前任务', `- ID: ${task.task_id}\n- 标题: ${task.title}\n- 状态: ${task.status}\n- 目标: ${task.objective ?? '未指定'}`, 1);
+                }
+                const events = getAuditEventsByTask(db, taskId);
+                if (events.length > 0) {
+                    const recent = events.slice(-5).map(e => `- [${e.event_type}] ${e.summary}`).join('\n');
+                    appendSection('最近事件', recent, events.length);
+                }
+            }
+            // 项目记忆
+            const projectId = input.vars.current_project;
+            if (projectId) {
+                const searchResult = await memorySearch(workspacePath, { query: projectId, project_id: projectId, limit: 3 });
+                if (searchResult.results.length > 0) {
+                    const content = searchResult.results.map(r => `- [${r.type}] ${r.content.slice(0, 200)}`).join('\n');
+                    appendSection('项目记忆', content, searchResult.results.length);
+                }
+            }
+            break;
+        }
+        case 'escalation': {
+            // 为升级场景提供组织信息和升级路径
+            const orgInfo = await orgLookup(db, workspacePath, {});
+            if (orgInfo.escalation_path && orgInfo.escalation_path.length > 0) {
+                const content = orgInfo.escalation_path.map(e => `- ${e.after_minutes}分钟后: ${e.action} → ${e.targets.join(', ')}`).join('\n');
+                appendSection('升级路径', content, orgInfo.escalation_path.length);
+            }
+            const taskId = input.vars.current_task;
+            if (taskId) {
+                const events = getAuditEventsByTask(db, taskId);
+                const blockerEvents = events.filter(e => e.event_type.includes('block') || e.event_type.includes('fail'));
+                if (blockerEvents.length > 0) {
+                    const content = blockerEvents.slice(-5).map(e => `- [${e.event_type}] ${e.summary}`).join('\n');
+                    appendSection('相关阻塞/失败事件', content, blockerEvents.length);
+                }
+            }
+            break;
+        }
+        case 'opportunity_eval': {
+            // 为机会评估提供活跃任务和承诺上下文
+            const tasks = getAllTasks(db);
+            const activeTasks = tasks.filter(t => !['DONE', 'CANCELLED'].includes(t.status));
+            if (activeTasks.length > 0) {
+                const content = activeTasks.slice(0, 10).map(t => `- [${t.task_id}] ${t.title} (${t.status})`).join('\n');
+                appendSection('活跃任务', content, activeTasks.length);
+            }
+            const commitments = getActiveCommitments(db);
+            if (commitments.length > 0) {
+                const content = commitments.map(c => `- [${c.task_id}] ${c.promise} (向 ${c.promised_to})`).join('\n');
+                appendSection('活跃承诺', content, commitments.length);
+            }
+            break;
+        }
+        case 'daily_report': {
+            // 为日报生成提供全面的状态概览
+            const tasks = getAllTasks(db);
+            const today = new Date().toISOString().slice(0, 10);
+            const doneTasks = tasks.filter(t => t.status === 'DONE' && t.updated_at?.startsWith(today));
+            const activeTasks = tasks.filter(t => ['IN_PROGRESS', 'READY', 'DELIVERING'].includes(t.status));
+            const blockedTasks = tasks.filter(t => t.status === 'BLOCKED');
+            if (doneTasks.length > 0) {
+                const content = doneTasks.map(t => `- [${t.task_id}] ${t.title}`).join('\n');
+                appendSection('今日完成', content, doneTasks.length);
+            }
+            if (activeTasks.length > 0) {
+                const content = activeTasks.map(t => `- [${t.task_id}] ${t.title} (${t.status})`).join('\n');
+                appendSection('进行中', content, activeTasks.length);
+            }
+            if (blockedTasks.length > 0) {
+                const content = blockedTasks.map(t => `- [${t.task_id}] ${t.title} — ${t.blocked_reason ?? '未知'}`).join('\n');
+                appendSection('阻塞项', content, blockedTasks.length);
+            }
+            const opportunities = getOpenOpportunities(db);
+            if (opportunities.length > 0) {
+                const content = opportunities.map(o => `- ${o.summary} (评分: ${o.total_score?.toFixed(2) ?? 'N/A'})`).join('\n');
+                appendSection('待处理机会', content, opportunities.length);
+            }
+            break;
+        }
+    }
+    return {
+        context: sections.join('\n\n'),
+        sources,
+        budget_used: budgetUsed,
+    };
+}
+//# sourceMappingURL=memory-context.js.map

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

@@ -0,0 +1,126 @@
+import { memoryRemember } from './memory-remember.js';
+const EXTRACTION_RULES = [
+    // 保留原有 3 条规则
+    {
+        patterns: [/fail/i, /失败/, /error/i, /错误/],
+        category: 'execution',
+        sub_type: 'failure',
+        importance: 0.8,
+        prefix: '失败记录',
+    },
+    {
+        patterns: [/decision/i, /决策/, /决定/],
+        category: 'project',
+        sub_type: 'decision',
+        importance: 0.6,
+        prefix: '决策记录',
+    },
+    {
+        patterns: [/block/i, /阻塞/, /卡住/, /stuck/i],
+        category: 'execution',
+        sub_type: 'failure',
+        importance: 0.7,
+        prefix: '阻塞经验',
+    },
+    // 新增：提取承诺类记忆
+    {
+        patterns: [/答应/, /承诺/, /保证/, /deadline/i, /截止/, /之前完成/],
+        category: 'commitment',
+        importance: 0.9,
+        prefix: '承诺记录',
+    },
+    // 新增：提取项目经验
+    {
+        patterns: [/注意/, /小心/, /别忘/, /踩坑/, /之前遇到/, /经验教训/, /切记/],
+        category: 'project',
+        sub_type: 'pitfall',
+        importance: 0.7,
+        prefix: '项目经验',
+    },
+];
+/**
+ * 消化对话/日志，提取记忆（替代 memory.reflect）
+ *
+ * 当前实现：增强版规则提取（不依赖外部 LLM，保持自包含）。
+ * // TODO: 升级为 Haiku LLM 提取，实现更精确的语义理解
+ */
+export async function memoryDigest(db, workspacePath, input) {
+    const entries = [];
+    const lines = input.conversation.split('\n').filter(l => l.trim());
+    // 基于规则提取
+    for (const line of lines) {
+        for (const rule of EXTRACTION_RULES) {
+            const matched = rule.patterns.some(p => p.test(line));
+            if (!matched)
+                continue;
+            entries.push({
+                content: `${rule.prefix}: ${line.trim()}`,
+                category: rule.category,
+                sub_type: rule.sub_type,
+            });
+            break; // 每行只匹配一条规则
+        }
+    }
+    // 去重
+    const seen = new Set();
+    const uniqueEntries = entries.filter(e => {
+        const key = `${e.category}:${e.content.slice(0, 50)}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    // 写入记忆
+    for (const entry of uniqueEntries) {
+        const rule = EXTRACTION_RULES.find(r => r.prefix === entry.content.split(':')[0]);
+        await memoryRemember(db, workspacePath, {
+            category: entry.category,
+            target: entry.category === 'project' ? input.project_id : undefined,
+            content: entry.content,
+            sub_type: entry.sub_type,
+            importance: rule?.importance ?? 0.5,
+            source: input.task_id,
+        });
+    }
+    // 如果提供了 sender_id，额外提取沟通信号写入 people
+    if (input.sender_id) {
+        const commSignals = extractCommunicationSignals(input.conversation);
+        for (const signal of commSignals) {
+            await memoryRemember(db, workspacePath, {
+                category: 'people',
+                target: input.sender_id,
+                content: signal,
+                importance: 0.4,
+                source: input.task_id,
+            });
+            uniqueEntries.push({
+                content: signal,
+                category: 'people',
+            });
+        }
+    }
+    return {
+        memories_created: uniqueEntries.length,
+        entries: uniqueEntries,
+    };
+}
+/**
+ * 从对话中提取沟通信号（偏好、习惯、关注点）
+ * // TODO: 升级为 Haiku LLM 提取
+ */
+function extractCommunicationSignals(conversation) {
+    const signals = [];
+    const lines = conversation.split('\n');
+    for (const line of lines) {
+        // 偏好表达
+        if (/喜欢|偏好|prefer|习惯/.test(line)) {
+            signals.push(`偏好观察: ${line.trim().slice(0, 100)}`);
+        }
+        // 不满/反馈
+        if (/不满|不好|不行|改进|问题/.test(line) && line.length > 10) {
+            signals.push(`反馈信号: ${line.trim().slice(0, 100)}`);
+        }
+    }
+    return signals.slice(0, 3); // 最多 3 条
+}
+//# sourceMappingURL=memory-digest.js.map