@lih-x-x/kmr 1.0.0

package/dist/index.js

@@ -0,0 +1,214 @@
+import { loadConfig, KMR_DIR } from './config';
+import { createLarkClient, createEventDispatcher, startWSClient } from './lark/client';
+import { DocReader } from './lark/docReader';
+import { Messenger } from './lark/messenger';
+import { parseMessage, MessageType } from './lark/router';
+import { ClaudeCodeProvider } from './agent/claudeCode';
+import { JsonStore } from './storage/jsonStore';
+import { QueryHandler } from './query/handler';
+import { startWebServer } from './web/server';
+import { openBrowser } from './web/openBrowser';
+import { SessionManager } from './session/manager';
+import { TaskCreator } from './lark/taskCreator';
+async function main() {
+    const config = loadConfig();
+    const client = createLarkClient(config);
+    const docReader = new DocReader(client);
+    const messenger = new Messenger(client);
+    const agent = new ClaudeCodeProvider(config.agent.timeout);
+    const store = new JsonStore(config.storage.dataDir);
+    const queryHandler = new QueryHandler(agent, config.storage.dataDir);
+    const sessionManager = new SessionManager(KMR_DIR, config.agent.timeout);
+    const taskCreator = new TaskCreator(client);
+    const pendingConfirmations = new Map();
+    const dispatcher = createEventDispatcher(async (messageId, text, _chatId, senderId, meta) => {
+        const parsed = parseMessage(text);
+        console.log(`[route] 消息路由: type=${parsed.type}, messageId=${messageId}, isGroup=${meta.isGroup}, isMentioned=${meta.isMentioned}`);
+        // 群聊非@消息 + 文档链接：需要验证文档标题是否为会议纪要
+        if (meta.isGroup && !meta.isMentioned && parsed.type === MessageType.DOCUMENT_LINK) {
+            const title = await docReader.getDocumentTitle(parsed.documentId);
+            console.log(`[filter] 群聊文档标题: "${title}"`);
+            const isMeetingNote = /纪要|会议记录|meeting/i.test(title) || /from=vc_assistant/.test(text);
+            if (!isMeetingNote) {
+                console.log(`[filter] 文档标题不含纪要关键词, 忽略`);
+                return;
+            }
+            console.log(`[filter] 确认为会议纪要, 继续处理`);
+        }
+        try {
+            switch (parsed.type) {
+                case MessageType.DOCUMENT_LINK: {
+                    console.log(`[process] 开始处理文档链接, documentId=${parsed.documentId}`);
+                    await messenger.replyText(messageId, '正在提取会议关键信息，请稍候...');
+                    console.log(`[reply] 已发送"正在提取"提示`);
+                    console.log(`[process] 读取飞书文档内容...`);
+                    const content = await docReader.readDocument(parsed.documentId);
+                    console.log(`[process] 文档内容读取完成, 长度=${content.length}`);
+                    console.log(`[process] 调用 Agent 提取会议信息...`);
+                    const record = await agent.extract(content);
+                    console.log(`[process] Agent 提取完成: title="${record.summary.title}"`);
+                    record.documentUrl = text.match(/(https?:\/\/[^\s]*feishu\.cn\/[^\s]+)/)?.[0] || '';
+                    await store.save(record);
+                    console.log(`✅ 会议提取成功: ${record.summary.title} (${record.id})`);
+                    await messenger.replyMeetingSummary(messageId, record);
+                    console.log(`[reply] 已发送会议摘要回复`);
+                    // 如果有待办，发确认消息
+                    if (record.todos.length > 0) {
+                        // 清理旧的待确认（如果有）
+                        const oldPending = pendingConfirmations.get(senderId);
+                        if (oldPending)
+                            clearTimeout(oldPending.timer);
+                        const timer = setTimeout(() => {
+                            const p = pendingConfirmations.get(senderId);
+                            if (p && p.meetingId === record.id) {
+                                pendingConfirmations.delete(senderId);
+                                console.log(`[timeout] 待办确认超时, userId=${senderId}, meetingId=${record.id}`);
+                            }
+                        }, 60_000);
+                        pendingConfirmations.set(senderId, {
+                            meetingId: record.id,
+                            todos: record.todos,
+                            createdAt: new Date().toISOString(),
+                            timer,
+                        });
+                        await messenger.replyTodoConfirmation(messageId, record.todos);
+                        console.log(`[reply] 已发送待办确认消息, ${record.todos.length} 条待办`);
+                    }
+                    break;
+                }
+                case MessageType.FIND_QUERY: {
+                    console.log(`[process] 开始搜索: query="${parsed.query}"`);
+                    const results = await queryHandler.find(parsed.query);
+                    console.log(`[process] 搜索完成, 结果数=${results.length}`);
+                    await messenger.replySearchResults(messageId, results);
+                    console.log(`[reply] 已发送搜索结果`);
+                    break;
+                }
+                case MessageType.LIST_ALL: {
+                    console.log(`[process] 列出所有记录`);
+                    const all = await store.list();
+                    console.log(`[process] 共 ${all.length} 条记录`);
+                    await messenger.replyRecordList(messageId, all);
+                    console.log(`[reply] 已发送记录列表`);
+                    break;
+                }
+                case MessageType.DELETE_RECORD: {
+                    console.log(`[process] 删除记录: id=${parsed.deleteId}`);
+                    const deleted = await store.delete(parsed.deleteId);
+                    if (deleted) {
+                        console.log(`✅ 记录已删除: ${parsed.deleteId}`);
+                        await messenger.replyText(messageId, `✅ 已删除记录: ${parsed.deleteId}`);
+                    }
+                    else {
+                        await messenger.replyText(messageId, `❌ 未找到记录: ${parsed.deleteId}`);
+                    }
+                    console.log(`[reply] 已发送删除结果`);
+                    break;
+                }
+                case MessageType.SHOW_DETAIL: {
+                    console.log(`[process] 查看详情: id=${parsed.showId}`);
+                    const detail = await store.load(parsed.showId);
+                    if (detail) {
+                        await messenger.replyRecordDetail(messageId, detail);
+                    }
+                    else {
+                        await messenger.replyText(messageId, `❌ 未找到记录: ${parsed.showId}`);
+                    }
+                    console.log(`[reply] 已发送详情`);
+                    break;
+                }
+                case MessageType.CONFIRM_TASKS: {
+                    const pending = pendingConfirmations.get(senderId);
+                    if (!pending) {
+                        await messenger.replyText(messageId, '没有待确认的待办事项。请先发送会议文档链接提取待办。');
+                        break;
+                    }
+                    clearTimeout(pending.timer);
+                    const selectedTodos = parsed.confirmIds === 'all'
+                        ? pending.todos
+                        : pending.todos.filter((_, i) => parsed.confirmIds.includes(i + 1));
+                    if (selectedTodos.length === 0) {
+                        await messenger.replyText(messageId, '未选中有效的待办编号，请检查后重试。');
+                        break;
+                    }
+                    console.log(`[process] 创建飞书任务: ${selectedTodos.length} 条`);
+                    await messenger.replyText(messageId, `正在创建 ${selectedTodos.length} 条飞书任务...`);
+                    const results = [];
+                    for (const todo of selectedTodos) {
+                        try {
+                            const result = await taskCreator.createTask({
+                                summary: `${todo.content}（${todo.owner}）`,
+                                due: todo.deadline,
+                                description: `来源会议: ${pending.meetingId}\n负责人: ${todo.owner}`,
+                                assigneeOpenId: senderId,
+                            });
+                            results.push({ summary: todo.content, success: true, taskId: result.taskId, url: result.url });
+                            console.log(`✅ 任务创建成功: ${todo.content}`);
+                        }
+                        catch (err) {
+                            results.push({ summary: todo.content, success: false, error: err.message });
+                            console.error(`❌ 任务创建失败: ${todo.content}`, err.message);
+                        }
+                    }
+                    await messenger.replyTaskResults(messageId, results);
+                    // 将创建的任务关联回会议记录
+                    const createdTasks = results
+                        .filter((r) => r.success)
+                        .map((r) => ({
+                        summary: r.summary,
+                        taskId: r.taskId || '',
+                        url: r.url || '',
+                        createdAt: new Date().toISOString(),
+                    }));
+                    if (createdTasks.length > 0) {
+                        const record = await store.load(pending.meetingId);
+                        if (record) {
+                            record.createdTasks = [...(record.createdTasks || []), ...createdTasks];
+                            await store.save(record);
+                            console.log(`[task] 已将 ${createdTasks.length} 条任务关联到会议 ${pending.meetingId}`);
+                        }
+                    }
+                    pendingConfirmations.delete(senderId);
+                    console.log(`[reply] 已发送任务创建结果`);
+                    break;
+                }
+                case MessageType.REJECT_TASKS: {
+                    const pending = pendingConfirmations.get(senderId);
+                    if (!pending) {
+                        await messenger.replyText(messageId, '没有待确认的待办事项。');
+                        break;
+                    }
+                    clearTimeout(pending.timer);
+                    pendingConfirmations.delete(senderId);
+                    await messenger.replyText(messageId, '✅ 已取消创建待办任务。');
+                    console.log(`[process] 用户拒绝创建任务, userId=${senderId}`);
+                    break;
+                }
+                case MessageType.UNKNOWN: {
+                    // 群聊非@消息不触发 AI 对话
+                    if (meta.isGroup && !meta.isMentioned) {
+                        console.log(`[filter] 群聊非@未知消息, 忽略`);
+                        break;
+                    }
+                    console.log(`[process] 自由对话, userId=${senderId}`);
+                    await messenger.replyText(messageId, '正在思考...');
+                    const reply = await sessionManager.handleMessage(senderId, text);
+                    await messenger.replyText(messageId, reply);
+                    console.log(`[reply] 已发送 AI 回复`);
+                    break;
+                }
+            }
+        }
+        catch (err) {
+            console.error('[error] 处理消息失败:', err);
+            await messenger.replyText(messageId, `处理失败: ${err.message}`);
+            console.log(`[reply] 已发送错误回复`);
+        }
+    });
+    startWSClient(client, dispatcher);
+    const { port } = await startWebServer(store, KMR_DIR, 3000);
+    openBrowser(`http://localhost:${port}`);
+    console.log(`KMR Web 界面已启动: http://localhost:${port}`);
+    console.log('KMR 服务已启动，等待飞书消息...');
+}
+main().catch(console.error);

package/dist/lark/client.d.ts

@@ -0,0 +1,8 @@
+import * as lark from '@larksuiteoapi/node-sdk';
+import { KmrConfig } from '../config';
+export declare function createLarkClient(config: KmrConfig): lark.Client;
+export declare function createEventDispatcher(onMessage: (messageId: string, text: string, chatId: string, senderId: string, meta: {
+    isGroup: boolean;
+    isMentioned: boolean;
+}) => Promise<void>): lark.EventDispatcher;
+export declare function startWSClient(client: lark.Client, dispatcher: lark.EventDispatcher): void;

package/dist/lark/client.js

@@ -0,0 +1,68 @@
+import * as lark from '@larksuiteoapi/node-sdk';
+export function createLarkClient(config) {
+    return new lark.Client({
+        appId: config.lark.appId,
+        appSecret: config.lark.appSecret,
+        appType: lark.AppType.SelfBuild,
+    });
+}
+export function createEventDispatcher(onMessage) {
+    const dispatcher = new lark.EventDispatcher({});
+    const processedMessages = new Set();
+    dispatcher.register({
+        'im.message.receive_v1': async (data) => {
+            console.log(`[recv] 收到飞书事件:`, JSON.stringify(data, null, 2));
+            const message = data.message;
+            if (message.message_type !== 'text') {
+                console.log(`[recv] 忽略非文本消息, type=${message.message_type}`);
+                return;
+            }
+            const messageId = message.message_id;
+            // 消息去重：飞书可能重复投递同一事件
+            if (processedMessages.has(messageId)) {
+                console.log(`[dedup] 跳过重复消息: ${messageId}`);
+                return;
+            }
+            processedMessages.add(messageId);
+            // 防止内存泄漏：保留最近 1000 条
+            if (processedMessages.size > 1000) {
+                const first = processedMessages.values().next().value;
+                processedMessages.delete(first);
+            }
+            const content = JSON.parse(message.content);
+            let text = content.text || '';
+            const chatId = message.chat_id;
+            // 群聊中 @机器人 的消息，去掉 @_user_N 占位符
+            const isMentioned = message.mentions && message.mentions.length > 0;
+            const isGroup = message.chat_type === 'group';
+            if (isMentioned) {
+                for (const mention of message.mentions) {
+                    if (mention.key) {
+                        text = text.replace(mention.key, '').trim();
+                    }
+                }
+            }
+            // 群聊中非 @机器人 的消息，只放行文档链接和待办确认/拒绝命令
+            if (isGroup && !isMentioned) {
+                const hasDocLink = /(https?:\/\/[^\s]*feishu\.cn\/[^\s]+)/.test(text);
+                const isConfirmOrReject = /^(?:\/confirm|\/reject|确认创建|取消创建|不创建|不用创建|全部创建|跳过待办|跳过|算了)\b/.test(text.trim());
+                if (!hasDocLink && !isConfirmOrReject) {
+                    console.log(`[recv] 群聊非@消息且非文档链接/待办确认, 忽略`);
+                    return;
+                }
+            }
+            console.log(`[recv] 解析消息: messageId=${messageId}, chatId=${chatId}, chatType=${message.chat_type}, text="${text}"`);
+            const senderId = data.sender?.sender_id?.open_id || 'unknown';
+            await onMessage(messageId, text, chatId, senderId, { isGroup, isMentioned });
+        },
+    });
+    return dispatcher;
+}
+export function startWSClient(client, dispatcher) {
+    const wsClient = new lark.WSClient({
+        appId: client.appId,
+        appSecret: client.appSecret,
+        loggerLevel: lark.LoggerLevel.info,
+    });
+    wsClient.start({ eventDispatcher: dispatcher });
+}

package/dist/lark/docReader.d.ts

@@ -0,0 +1,9 @@
+import * as lark from '@larksuiteoapi/node-sdk';
+export declare function extractDocumentId(url: string): string | null;
+export declare class DocReader {
+    private readonly client;
+    constructor(client: lark.Client);
+    getDocumentTitle(documentId: string): Promise<string>;
+    readDocument(documentId: string): Promise<string>;
+    private extractBlockText;
+}

package/dist/lark/docReader.js

@@ -0,0 +1,75 @@
+export function extractDocumentId(url) {
+    const patterns = [
+        /feishu\.cn\/docx\/([a-zA-Z0-9]+)/,
+        /feishu\.cn\/wiki\/([a-zA-Z0-9]+)/,
+        /feishu\.cn\/docs\/([a-zA-Z0-9]+)/,
+    ];
+    for (const pattern of patterns) {
+        const match = url.match(pattern);
+        if (match)
+            return match[1];
+    }
+    return null;
+}
+export class DocReader {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getDocumentTitle(documentId) {
+        try {
+            const response = await this.client.docx.document.get({
+                path: { document_id: documentId },
+            });
+            return response.data?.document?.title || '';
+        }
+        catch (err) {
+            console.error(`[docReader] 获取文档标题失败: ${err.message}`);
+            return '';
+        }
+    }
+    async readDocument(documentId) {
+        const blocks = [];
+        let pageToken;
+        // 分页获取所有 block
+        do {
+            const response = await this.client.docx.documentBlock.list({
+                path: { document_id: documentId },
+                params: { page_size: 500, ...(pageToken ? { page_token: pageToken } : {}) },
+            });
+            if (response.data?.items) {
+                for (const block of response.data.items) {
+                    const text = this.extractBlockText(block);
+                    if (text)
+                        blocks.push(text);
+                }
+            }
+            pageToken = response.data?.page_token || undefined;
+        } while (pageToken);
+        console.log(`[docReader] 文档 ${documentId} 共提取 ${blocks.length} 个文本块`);
+        return blocks.join('\n');
+    }
+    extractBlockText(block) {
+        // 尝试从多种 block 类型中提取文本
+        const textSources = [
+            block.text, // 普通文本
+            block.heading, // 标题
+            block.bullet, // 无序列表
+            block.ordered, // 有序列表
+            block.code, // 代码块
+            block.quote, // 引用
+            block.todo, // 待办
+            block.callout, // 高亮块
+        ];
+        for (const source of textSources) {
+            if (source?.elements) {
+                const text = source.elements
+                    .map((el) => el.text_run?.content || el.mention_user?.content || '')
+                    .join('');
+                if (text)
+                    return text;
+            }
+        }
+        return '';
+    }
+}

package/dist/lark/messenger.d.ts

@@ -0,0 +1,22 @@
+import * as lark from '@larksuiteoapi/node-sdk';
+import { MeetingRecord } from '../storage/types';
+export declare class Messenger {
+    private readonly client;
+    constructor(client: lark.Client);
+    replyText(messageId: string, text: string): Promise<void>;
+    replyMeetingSummary(messageId: string, record: MeetingRecord): Promise<void>;
+    replyRecordList(messageId: string, records: MeetingRecord[]): Promise<void>;
+    replyRecordDetail(messageId: string, record: MeetingRecord): Promise<void>;
+    replySearchResults(messageId: string, results: MeetingRecord[]): Promise<void>;
+    replyTodoConfirmation(messageId: string, todos: {
+        content: string;
+        owner: string;
+        deadline: string;
+    }[]): Promise<void>;
+    replyTaskResults(messageId: string, results: {
+        summary: string;
+        success: boolean;
+        url?: string;
+        error?: string;
+    }[]): Promise<void>;
+}

package/dist/lark/messenger.js

@@ -0,0 +1,156 @@
+export class Messenger {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async replyText(messageId, text) {
+        await this.client.im.message.reply({
+            path: { message_id: messageId },
+            data: {
+                content: JSON.stringify({ text }),
+                msg_type: 'text',
+            },
+        });
+    }
+    async replyMeetingSummary(messageId, record) {
+        const lines = [
+            `✅ 会议关键信息提取完成`,
+            '',
+            `📋 **${record.summary.title}**`,
+            `📅 日期：${record.summary.date}`,
+            `👥 参与人：${record.summary.participants.join('、')}`,
+            '',
+            '**核心要点：**',
+            ...record.summary.keyPoints.map((p) => `• ${p}`),
+        ];
+        if (record.todos.length > 0) {
+            lines.push('', '**待办事项：**');
+            for (const todo of record.todos) {
+                lines.push(`• ${todo.content}（${todo.owner}，截止 ${todo.deadline}）`);
+            }
+        }
+        if (record.risks.length > 0) {
+            lines.push('', '**风险项：**');
+            for (const risk of record.risks) {
+                lines.push(`• [${risk.severity}] ${risk.description}`);
+            }
+        }
+        if (record.commitments.length > 0) {
+            lines.push('', '🤝 **关键共识与承诺：**');
+            for (const c of record.commitments) {
+                lines.push(`• ${c.content}`);
+                lines.push(`  相关方：${c.participants.join('、')}${c.deadline ? `，截止 ${c.deadline}` : ''}`);
+                lines.push(`  💡 ${c.context}`);
+            }
+        }
+        if (record.reusableInsights.length > 0) {
+            lines.push('', '🧠 **可复用知识：**');
+            for (const r of record.reusableInsights) {
+                lines.push(`• [${r.category}] ${r.content}`);
+                lines.push(`  适用场景：${r.scenario}`);
+            }
+        }
+        await this.replyText(messageId, lines.join('\n'));
+    }
+    async replyRecordList(messageId, records) {
+        if (records.length === 0) {
+            await this.replyText(messageId, '暂无会议记录');
+            return;
+        }
+        const lines = [`📂 共 ${records.length} 条会议记录：`, ''];
+        for (const r of records) {
+            lines.push(`• ${r.id}`);
+            lines.push(`  ${r.summary.title}（${r.summary.date}）`);
+            if (r.documentUrl)
+                lines.push(`  ${r.documentUrl}`);
+            lines.push('');
+        }
+        lines.push('使用 /show <id> 查看详情，/del <id> 删除记录');
+        await this.replyText(messageId, lines.join('\n'));
+    }
+    async replyRecordDetail(messageId, record) {
+        const lines = [
+            `📋 **${record.summary.title}**`,
+            `📅 日期：${record.summary.date}`,
+            `👥 参与人：${record.summary.participants.join('、')}`,
+            `🆔 ${record.id}`,
+        ];
+        if (record.documentUrl) {
+            lines.push(`🔗 ${record.documentUrl}`);
+        }
+        lines.push('', '**核心要点：**');
+        for (const p of record.summary.keyPoints) {
+            lines.push(`• ${p}`);
+        }
+        if (record.commitments && record.commitments.length > 0) {
+            lines.push('', '🤝 **关键共识与承诺：**');
+            for (const c of record.commitments) {
+                lines.push(`• ${c.content}`);
+                lines.push(`  相关方：${c.participants.join('、')}${c.deadline ? `，截止 ${c.deadline}` : ''}`);
+                lines.push(`  💡 ${c.context}`);
+            }
+        }
+        if (record.reusableInsights && record.reusableInsights.length > 0) {
+            lines.push('', '🧠 **可复用知识：**');
+            for (const r of record.reusableInsights) {
+                lines.push(`• [${r.category}] ${r.content}`);
+                lines.push(`  适用场景：${r.scenario}`);
+            }
+        }
+        if (record.todos && record.todos.length > 0) {
+            lines.push('', '**待办事项：**');
+            for (const t of record.todos) {
+                lines.push(`• ${t.content}（${t.owner}，截止 ${t.deadline}）`);
+            }
+        }
+        if (record.risks && record.risks.length > 0) {
+            lines.push('', '**风险项：**');
+            for (const r of record.risks) {
+                lines.push(`• [${r.severity}] ${r.description}`);
+            }
+        }
+        await this.replyText(messageId, lines.join('\n'));
+    }
+    async replySearchResults(messageId, results) {
+        if (results.length === 0) {
+            await this.replyText(messageId, '未找到相关会议记录');
+            return;
+        }
+        const lines = ['🔍 找到以下相关会议：', ''];
+        for (const r of results.slice(0, 3)) {
+            lines.push(`• **${r.summary.title}**（${r.summary.date}）`);
+            lines.push(`  要点：${r.summary.keyPoints[0] || '无'}`);
+            lines.push(`  链接：${r.documentUrl}`);
+            lines.push('');
+        }
+        await this.replyText(messageId, lines.join('\n'));
+    }
+    async replyTodoConfirmation(messageId, todos) {
+        const lines = [
+            `📝 检测到 ${todos.length} 条待办，是否创建飞书任务？`,
+            '',
+        ];
+        todos.forEach((t, i) => {
+            lines.push(`${i + 1}. [${t.owner}] ${t.content}${t.deadline ? `（截止 ${t.deadline}）` : ''}`);
+        });
+        lines.push('', '回复 /confirm all 创建全部');
+        lines.push('回复 /confirm 1,2 创建选中的任务');
+        lines.push('回复 /reject 取消创建');
+        lines.push('', '⏱ 1 分钟内未回复将自动取消');
+        await this.replyText(messageId, lines.join('\n'));
+    }
+    async replyTaskResults(messageId, results) {
+        const lines = ['📋 飞书任务创建结果：', ''];
+        for (const r of results) {
+            if (r.success) {
+                lines.push(`✅ ${r.summary}`);
+                if (r.url)
+                    lines.push(`   ${r.url}`);
+            }
+            else {
+                lines.push(`❌ ${r.summary} — ${r.error || '创建失败'}`);
+            }
+        }
+        await this.replyText(messageId, lines.join('\n'));
+    }
+}

package/dist/lark/router.d.ts

@@ -0,0 +1,20 @@
+export declare enum MessageType {
+    DOCUMENT_LINK = "document_link",
+    FIND_QUERY = "find_query",
+    LIST_ALL = "list_all",
+    DELETE_RECORD = "delete_record",
+    SHOW_DETAIL = "show_detail",
+    CONFIRM_TASKS = "confirm_tasks",
+    REJECT_TASKS = "reject_tasks",
+    UNKNOWN = "unknown"
+}
+export interface ParsedMessage {
+    type: MessageType;
+    documentId?: string;
+    query?: string;
+    deleteId?: string;
+    showId?: string;
+    confirmIds?: number[] | 'all';
+    raw: string;
+}
+export declare function parseMessage(text: string): ParsedMessage;

package/dist/lark/router.js

@@ -0,0 +1,75 @@
+import { extractDocumentId } from './docReader';
+export var MessageType;
+(function (MessageType) {
+    MessageType["DOCUMENT_LINK"] = "document_link";
+    MessageType["FIND_QUERY"] = "find_query";
+    MessageType["LIST_ALL"] = "list_all";
+    MessageType["DELETE_RECORD"] = "delete_record";
+    MessageType["SHOW_DETAIL"] = "show_detail";
+    MessageType["CONFIRM_TASKS"] = "confirm_tasks";
+    MessageType["REJECT_TASKS"] = "reject_tasks";
+    MessageType["UNKNOWN"] = "unknown";
+})(MessageType || (MessageType = {}));
+export function parseMessage(text) {
+    const trimmed = text.trim();
+    // /reject 或 "取消创建"/"不创建"/"跳过待办"
+    if (/^(?:\/reject|取消创建|不创建|不用创建|跳过待办|跳过|算了)$/i.test(trimmed)) {
+        return { type: MessageType.REJECT_TASKS, raw: text };
+    }
+    // /confirm all 或 /confirm 1,2,3 或自然语言"确认创建全部/确认创建 1,2"
+    const confirmAllMatch = /^(?:\/confirm\s+all|确认创建全部|全部创建)$/i.test(trimmed);
+    if (confirmAllMatch) {
+        return { type: MessageType.CONFIRM_TASKS, confirmIds: 'all', raw: text };
+    }
+    const confirmMatch = trimmed.match(/^(?:\/confirm|确认创建)\s+([\d,\s]+)/);
+    if (confirmMatch) {
+        const ids = confirmMatch[1].split(/[,\s，]+/).map(Number).filter((n) => n > 0);
+        if (ids.length > 0) {
+            return { type: MessageType.CONFIRM_TASKS, confirmIds: ids, raw: text };
+        }
+    }
+    // /del <id> 或 "删掉/删除 <id>"
+    const delMatch = trimmed.match(/^(?:\/del|删掉|删除)\s+(.+)/);
+    if (delMatch) {
+        return {
+            type: MessageType.DELETE_RECORD,
+            deleteId: delMatch[1].trim(),
+            raw: text,
+        };
+    }
+    // /show <id> 或 "展示/列出/查看 <id> 的详情" 等
+    const showMatch = trimmed.match(/^(?:\/show)\s+(.+)/) ||
+        trimmed.match(/^(?:展示|列出|显示|查看)\s*(meeting_\w+)/) ||
+        trimmed.match(/^(?:展示|列出|显示|查看)\s*(.+?)的?详情/);
+    if (showMatch) {
+        return {
+            type: MessageType.SHOW_DETAIL,
+            showId: showMatch[1].trim(),
+            raw: text,
+        };
+    }
+    // /listall 或自然语言匹配
+    if (/^\/listall$/i.test(trimmed) || /^(展示|列出|显示|查看)(所有|全部|历史)(记录|会议)/.test(trimmed)) {
+        return { type: MessageType.LIST_ALL, raw: text };
+    }
+    const findMatch = text.match(/^\/find\s+(.+)/);
+    if (findMatch) {
+        return {
+            type: MessageType.FIND_QUERY,
+            query: findMatch[1].trim(),
+            raw: text,
+        };
+    }
+    const urlMatch = text.match(/(https?:\/\/[^\s]*feishu\.cn\/[^\s]+)/);
+    if (urlMatch) {
+        const docId = extractDocumentId(urlMatch[1]);
+        if (docId) {
+            return {
+                type: MessageType.DOCUMENT_LINK,
+                documentId: docId,
+                raw: text,
+            };
+        }
+    }
+    return { type: MessageType.UNKNOWN, raw: text };
+}

package/dist/lark/taskCreator.d.ts

@@ -0,0 +1,15 @@
+import * as lark from '@larksuiteoapi/node-sdk';
+export interface CreateTaskResult {
+    taskId: string;
+    url: string;
+}
+export declare class TaskCreator {
+    private readonly client;
+    constructor(client: lark.Client);
+    createTask(params: {
+        summary: string;
+        due?: string;
+        description?: string;
+        assigneeOpenId?: string;
+    }): Promise<CreateTaskResult>;
+}