team-anya-cli 0.1.1 → 0.1.3

package/apps/server/dist/loid/dispatcher.js

@@ -1,544 +0,0 @@
-import { spawn } from 'node:child_process';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
-import { getTask, getTasksByStatus, updateTask, getCommitmentByTask, insertAuditEvent, getMessageLogBySourceRef } from '@team-anya/db';
-import { TaskStatus } from '@team-anya/core';
-export class Dispatcher {
-    slots;
-    db;
-    config;
-    logger;
-    spawnFn;
-    targetConcurrency;
-    shuttingDown = false;
-    shutdownResolve = null;
-    onTaskStatusChange;
-    briefAssembler;
-    onTaskComplete;
-    onDeliveryReady;
-    worktreeManager;
-    constructor(deps, spawnFn) {
-        this.db = deps.db;
-        this.config = deps.config;
-        this.logger = deps.logger ?? { info: console.log, error: console.error };
-        this.spawnFn = spawnFn ?? spawn;
-        this.onTaskStatusChange = deps.onTaskStatusChange;
-        this.briefAssembler = deps.briefAssembler;
-        this.onTaskComplete = deps.onTaskComplete;
-        this.onDeliveryReady = deps.onDeliveryReady ?? undefined;
-        this.worktreeManager = deps.worktreeManager;
-        this.targetConcurrency = deps.config.MAX_YOR_CONCURRENCY;
-        this.slots = Array.from({ length: deps.config.MAX_YOR_CONCURRENCY }, (_, i) => ({
-            index: i,
-            busy: false,
-            taskId: null,
-            process: null,
-            startedAt: null,
-        }));
-    }
-    /**
-     * 设置 Yor 交付完成后的回调（唤醒 Loid 验收）
-     */
-    setDeliveryCallback(cb) {
-        this.onDeliveryReady = cb;
-    }
-    getSlots() {
-        return this.slots.map(s => ({ ...s, process: null })); // 不暴露 process 引用
-    }
-    /**
-     * 获取每个槽位的详细状态
-     */
-    getSlotStatus() {
-        return this.slots.map(s => ({
-            id: s.index,
-            taskId: s.taskId,
-            startedAt: s.startedAt,
-            status: s.busy ? 'busy' : 'idle',
-        }));
-    }
-    /**
-     * 获取槽位使用率指标
-     * total 以 targetConcurrency 为准（而非实际 slots 数组长度），
-     * 因为缩减并发度时忙碌槽位可能暂时超出 targetConcurrency
-     */
-    getUtilization() {
-        const busy = this.slots.filter(s => s.busy).length;
-        return {
-            total: this.targetConcurrency,
-            busy,
-            idle: Math.max(0, this.targetConcurrency - busy),
-        };
-    }
-    /**
-     * 动态调整最大并发度
-     * - 增加：立即扩展 slots 数组
-     * - 减少：不中断正在运行的任务，只回收空闲的多余槽位
-     */
-    setConcurrency(n) {
-        if (n < 1) {
-            throw new Error(`并发度必须 >= 1，收到 ${n}`);
-        }
-        this.targetConcurrency = n;
-        if (n > this.slots.length) {
-            // 增加槽位
-            const startIndex = this.slots.length;
-            for (let i = startIndex; i < n; i++) {
-                this.slots.push({
-                    index: i,
-                    busy: false,
-                    taskId: null,
-                    process: null,
-                    startedAt: null,
-                });
-            }
-        }
-        else if (n < this.slots.length) {
-            // 减少：回收空闲的超出槽位（从末尾开始）
-            this.shrinkIdleSlots();
-        }
-    }
-    /**
-     * 回收超出 targetConcurrency 的空闲槽位
-     */
-    shrinkIdleSlots() {
-        // 从末尾向前移除空闲的超出槽位
-        while (this.slots.length > this.targetConcurrency) {
-            const last = this.slots[this.slots.length - 1];
-            if (last.busy)
-                break; // 忙碌的不能回收
-            this.slots.pop();
-        }
-    }
-    findFreeSlot() {
-        // 只在 targetConcurrency 范围内查找空闲槽位
-        for (const slot of this.slots) {
-            if (!slot.busy && slot.index < this.targetConcurrency) {
-                return slot;
-            }
-        }
-        return null;
-    }
-    /**
-     * 派工：找空闲槽位 → 更新 DB → spawn Yor 子进程
-     */
-    async dispatch(taskId) {
-        if (this.shuttingDown)
-            return false;
-        const task = getTask(this.db, taskId);
-        if (!task) {
-            this.logger.error(`[派工] 失败: 任务 ${taskId} 不存在`);
-            return false;
-        }
-        if (task.status !== TaskStatus.READY) {
-            this.logger.error(`[派工] 失败: ${taskId} 状态 ${task.status}，需要 READY`);
-            return false;
-        }
-        const slot = this.findFreeSlot();
-        if (!slot)
-            return false;
-        // Brief 组装（失败不阻止派工）
-        if (this.briefAssembler) {
-            try {
-                const briefContent = await this.briefAssembler.assembleBrief(taskId);
-                const taskDir = resolve(this.config.WORKSPACE_PATH, 'yor', 'tasks', taskId);
-                await mkdir(taskDir, { recursive: true });
-                await writeFile(resolve(taskDir, 'brief.md'), briefContent, 'utf-8');
-            }
-            catch (err) {
-                this.logger.error(`[派工] Brief 组装失败 (${taskId}), 继续:`, err);
-            }
-        }
-        // 准备工作目录
-        let workspace = null;
-        if (this.worktreeManager) {
-            try {
-                this.logger.info(`[anya:pipeline] [dispatch] prepare 开始 | task=${taskId} project_id=${task.project_id ?? 'null'}`);
-                workspace = await this.worktreeManager.prepare(taskId, task.project_id ?? undefined);
-                this.logger.info(`[anya:pipeline] [dispatch] prepare 完成 | mode=${workspace.mode} workingDir=${workspace.workingDir} repos=${workspace.repos?.length ?? 0}`);
-            }
-            catch (err) {
-                this.logger.error(`[anya:pipeline] [Yor] 启动失败 ${taskId}: 工作目录准备出错`, err);
-                return false;
-            }
-        }
-        else {
-            this.logger.info(`[anya:pipeline] [dispatch] 无 worktreeManager，跳过 prepare`);
-        }
-        const workingDir = resolve(workspace?.workingDir ?? this.config.WORKSPACE_PATH);
-        // 更新任务状态为 IN_PROGRESS
-        updateTask(this.db, taskId, {
-            status: TaskStatus.IN_PROGRESS,
-            assignee: `yor-slot-${slot.index}`,
-            workspace_path: workingDir,
-            branch: workspace?.branch ?? null,
-        });
-        // 占据槽位
-        slot.busy = true;
-        slot.taskId = taskId;
-        slot.startedAt = new Date().toISOString();
-        // spawn Yor 子进程
-        // cwd 设为 Yor 入口所在目录（确保能找到 node_modules）
-        // --workspace 传实际工作目录给 Yor
-        const yorEntry = resolve(this.config.YOR_ENTRY);
-        const yorCwd = dirname(yorEntry);
-        const briefPath = resolve(this.config.WORKSPACE_PATH, 'yor', 'tasks', taskId, 'brief.md');
-        const child = this.spawnFn('npx', [
-            'tsx', yorEntry,
-            '--task', taskId,
-            '--workspace', workingDir,
-            '--brief', briefPath,
-            '--title', task.title ?? '',
-        ], {
-            cwd: yorCwd,
-            env: {
-                ...process.env,
-                SQLITE_PATH: this.config.SQLITE_PATH,
-                WORKSPACE_PATH: this.config.WORKSPACE_PATH,
-                CLAUDE_CODE_BINARY: this.config.CLAUDE_CODE_BINARY,
-            },
-            stdio: 'pipe',
-        });
-        slot.process = child;
-        // 捕获 stderr 用于诊断崩溃原因
-        let stderrBuf = '';
-        child.stderr?.on('data', (data) => {
-            stderrBuf += data.toString();
-        });
-        child.on('exit', (code) => {
-            if (code !== 0 && stderrBuf.trim()) {
-                this.logger.error(`[anya:pipeline] [Yor] stderr (${taskId}): ${stderrBuf.trim().slice(0, 500)}`);
-            }
-            this.onYorExit(slot, code);
-        });
-        child.on('error', (err) => {
-            this.logger.error(`[anya:pipeline] [Yor] 进程异常 ${taskId}:`, err);
-            this.onYorExit(slot, 1);
-        });
-        // 一条日志说清 Yor 启动的关键信息
-        const modeLabel = workspace?.mode === 'product'
-            ? `product=${task.project_id} repos=${workspace.repos?.length ?? 0}`
-            : task.project_id ? `project=${task.project_id}` : 'scratch';
-        const branchLabel = workspace?.branch ? ` branch=${workspace.branch}` : '';
-        this.logger.info(`[anya:pipeline] [Yor] 启动 ${taskId} | slot=${slot.index} ${modeLabel}${branchLabel} | cwd=${workingDir}`);
-        return true;
-    }
-    /**
-     * 扫描 READY 任务，按优先级排序后依次派工
-     * 优先级：有 commitment deadline 的任务优先（deadline 越近越优先），无 deadline 的按 created_at 排序
-     */
-    async drainReadyQueue() {
-        if (this.shuttingDown)
-            return 0;
-        const readyTasks = getTasksByStatus(this.db, TaskStatus.READY);
-        // 按优先级排序
-        const sorted = this.sortByPriority(readyTasks);
-        let dispatched = 0;
-        for (const task of sorted) {
-            if (!this.findFreeSlot())
-                break;
-            if (await this.dispatch(task.task_id)) {
-                dispatched++;
-            }
-        }
-        return dispatched;
-    }
-    /**
-     * 按优先级排序任务
-     * 1. 有 commitment deadline 的优先（deadline 越近越优先）
-     * 2. 无 deadline 的按 created_at 排序（越早越优先）
-     */
-    sortByPriority(tasks) {
-        // 获取每个任务的 commitment deadline
-        const deadlineMap = new Map();
-        for (const task of tasks) {
-            const commitment = getCommitmentByTask(this.db, task.task_id);
-            deadlineMap.set(task.task_id, commitment?.deadline ?? null);
-        }
-        return [...tasks].sort((a, b) => {
-            const deadlineA = deadlineMap.get(a.task_id) ?? null;
-            const deadlineB = deadlineMap.get(b.task_id) ?? null;
-            // 有 deadline 的排前面
-            if (deadlineA && !deadlineB)
-                return -1;
-            if (!deadlineA && deadlineB)
-                return 1;
-            // 都有 deadline：deadline 越近越优先
-            if (deadlineA && deadlineB) {
-                return deadlineA.localeCompare(deadlineB);
-            }
-            // 都无 deadline：按 created_at 排序
-            return (a.created_at ?? '').localeCompare(b.created_at ?? '');
-        });
-    }
-    /**
-     * 启动时崩溃恢复：将 IN_PROGRESS 任务重置为 READY
-     */
-    recover() {
-        const inProgress = getTasksByStatus(this.db, TaskStatus.IN_PROGRESS);
-        let recovered = 0;
-        for (const task of inProgress) {
-            // IN_PROGRESS 不能直接回 READY，需要先 BLOCKED 再 READY
-            // 但恢复场景特殊，直接标记为 BLOCKED 再恢复为 READY
-            updateTask(this.db, task.task_id, {
-                status: TaskStatus.BLOCKED,
-                blocked_reason: '服务重启崩溃恢复',
-                blocked_since: new Date().toISOString(),
-                assignee: null,
-            });
-            updateTask(this.db, task.task_id, {
-                status: TaskStatus.READY,
-                blocked_reason: null,
-                blocked_since: null,
-            });
-            recovered++;
-        }
-        return recovered;
-    }
-    /**
-     * C1 增强崩溃恢复：
-     * 1. 扫描 IN_PROGRESS 任务
-     * 2. 检查 execution-log.jsonl 最后事件 → 判断可恢复/需重置
-     * 3. 可恢复（有 sessionId + 最后事件非错误）→ 标记为 resume 策略
-     * 4. 不可恢复 → 重置为 READY
-     * 5. 写审计日志
-     */
-    async recoverEnhanced() {
-        const inProgress = getTasksByStatus(this.db, TaskStatus.IN_PROGRESS);
-        const details = [];
-        let resumed = 0;
-        let reset = 0;
-        for (const task of inProgress) {
-            const taskDir = resolve(this.config.WORKSPACE_PATH, 'yor', 'tasks', task.task_id);
-            // 读取 execution-log.jsonl 最后一行
-            const lastEvent = await this.readLastLogEvent(join(taskDir, 'execution-log.jsonl'));
-            // 读取 handoff.md 中的 sessionId
-            const sessionId = await this.extractSessionId(join(taskDir, 'handoff.md'));
-            // 判断恢复策略
-            const isRecoverable = lastEvent !== null
-                && lastEvent.type !== 'ERROR'
-                && sessionId !== null;
-            if (isRecoverable) {
-                // 可恢复：保持 IN_PROGRESS，记录 resume 信息
-                resumed++;
-                details.push({ taskId: task.task_id, strategy: 'resume', sessionId: sessionId });
-                insertAuditEvent(this.db, {
-                    event_type: 'crash_recovery',
-                    actor: 'system',
-                    task_id: task.task_id,
-                    summary: `崩溃恢复: 任务可通过 session resume 恢复`,
-                    detail: JSON.stringify({ strategy: 'resume', sessionId, lastEvent }),
-                });
-            }
-            else {
-                // 不可恢复：重置为 READY
-                updateTask(this.db, task.task_id, {
-                    status: TaskStatus.BLOCKED,
-                    blocked_reason: '服务重启崩溃恢复',
-                    blocked_since: new Date().toISOString(),
-                    assignee: null,
-                });
-                updateTask(this.db, task.task_id, {
-                    status: TaskStatus.READY,
-                    blocked_reason: null,
-                    blocked_since: null,
-                });
-                reset++;
-                details.push({ taskId: task.task_id, strategy: 'reset' });
-                insertAuditEvent(this.db, {
-                    event_type: 'crash_recovery',
-                    actor: 'system',
-                    task_id: task.task_id,
-                    summary: `崩溃恢复: 任务重置为 READY 重新派工`,
-                    detail: JSON.stringify({ strategy: 'reset', reason: lastEvent ? `最后事件: ${lastEvent.type}` : '无执行日志' }),
-                });
-            }
-        }
-        return { total: inProgress.length, resumed, reset, details };
-    }
-    /**
-     * 读取 execution-log.jsonl 的最后一行并解析
-     */
-    async readLastLogEvent(logPath) {
-        try {
-            const content = await readFile(logPath, 'utf-8');
-            const lines = content.trim().split('\n').filter(l => l.trim().length > 0);
-            if (lines.length === 0)
-                return null;
-            return JSON.parse(lines[lines.length - 1]);
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * 从 handoff.md 中提取 sessionId
-     * 格式: "sessionId: xxx" 或 "sessionId:xxx"
-     */
-    async extractSessionId(handoffPath) {
-        try {
-            const content = await readFile(handoffPath, 'utf-8');
-            const match = content.match(/sessionId:\s*(\S+)/);
-            return match ? match[1] : null;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * 优雅关闭
-     * 1. 标记为关闭中，不再接受新派工
-     * 2. 等待进行中任务完成
-     * 3. 超时后发 SIGTERM，返回未完成的任务列表
-     */
-    async shutdown(timeoutMs = 30_000) {
-        this.shuttingDown = true;
-        const busySlots = this.slots.filter(s => s.busy);
-        if (busySlots.length === 0) {
-            return { unfinished: [] };
-        }
-        // 等待所有忙碌槽位完成，或超时
-        return new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                // 超时：发送 SIGTERM 给所有仍在运行的进程
-                const unfinished = [];
-                for (const slot of this.slots) {
-                    if (slot.busy && slot.process) {
-                        slot.process.kill('SIGTERM');
-                        if (slot.taskId) {
-                            unfinished.push(slot.taskId);
-                        }
-                    }
-                }
-                resolve({ unfinished });
-            }, timeoutMs);
-            // 设置 resolve 回调，让 onYorExit 可以在所有任务完成时触发
-            this.shutdownResolve = () => {
-                clearTimeout(timer);
-                resolve({ unfinished: [] });
-            };
-        });
-    }
-    /**
-     * Yor 子进程退出回调
-     */
-    onYorExit(slot, code) {
-        const taskId = slot.taskId;
-        if (taskId) {
-            const label = code === 0 ? '正常退出' : `异常退出 code=${code}`;
-            this.logger.info(`[anya:pipeline] [Yor] 结束 ${taskId} | ${label}`);
-        }
-        // 释放槽位
-        slot.busy = false;
-        slot.taskId = null;
-        slot.process = null;
-        slot.startedAt = null;
-        // 异步清理工作目录（不阻塞后续流程）
-        if (taskId && this.worktreeManager) {
-            const task = getTask(this.db, taskId);
-            this.worktreeManager.cleanup(taskId, task?.project_id ?? undefined).catch(err => {
-                this.logger.error(`[WorktreeManager] 清理失败 (${taskId}):`, err);
-            });
-        }
-        if (taskId) {
-            const task = getTask(this.db, taskId);
-            if (task) {
-                if (code !== 0 && task.status === TaskStatus.IN_PROGRESS) {
-                    // 非正常退出，标记为 BLOCKED
-                    updateTask(this.db, taskId, {
-                        status: TaskStatus.BLOCKED,
-                        blocked_reason: `Yor 进程异常退出 (code: ${code})`,
-                        blocked_since: new Date().toISOString(),
-                    });
-                    this.onTaskStatusChange?.(taskId, TaskStatus.BLOCKED, {
-                        reason: `Yor 进程异常退出 (code: ${code})`,
-                    });
-                }
-            }
-            // 唤醒 Loid 验收（核心改动）
-            if (this.onDeliveryReady) {
-                this.buildDeliveryContext(taskId, code).then(deliveryCtx => {
-                    return this.onDeliveryReady(deliveryCtx);
-                }).catch(err => {
-                    this.logger.error('[Loid] 验收触发失败:', err);
-                });
-            }
-        }
-        // 触发后处理回调（异步，不阻塞 drainReadyQueue）
-        if (taskId && code === 0 && this.onTaskComplete) {
-            this.onTaskComplete(taskId, code).catch(err => {
-                this.logger.error('[Yor] 后处理失败:', err);
-            });
-        }
-        // 缩减时回收超出的空闲槽位
-        this.shrinkIdleSlots();
-        // 检查是否所有任务都已完成（shutdown 等待中）
-        if (this.shuttingDown && this.shutdownResolve) {
-            const stillBusy = this.slots.some(s => s.busy);
-            if (!stillBusy) {
-                this.shutdownResolve();
-                this.shutdownResolve = null;
-            }
-        }
-        // 非 shutdown 模式下尝试继续消费 ready queue
-        if (!this.shuttingDown) {
-            this.drainReadyQueue().catch(err => {
-                this.logger.error('[派工] drainReadyQueue 失败:', err);
-            });
-        }
-    }
-    /**
-     * 构建 Yor 交付上下文，供 Loid 验收
-     */
-    async buildDeliveryContext(taskId, exitCode) {
-        const task = getTask(this.db, taskId);
-        const taskDir = resolve(this.config.WORKSPACE_PATH, 'yor', 'tasks', taskId);
-        // 读取 brief
-        let briefContent = null;
-        try {
-            briefContent = await readFile(join(taskDir, 'brief.md'), 'utf-8');
-        }
-        catch {
-            // brief 可能不存在
-        }
-        // 读取执行结果
-        let testResults = null;
-        try {
-            testResults = await readFile(join(taskDir, 'test-results.txt'), 'utf-8');
-        }
-        catch {
-            // 测试结果可能不存在
-        }
-        // 读取变更文件列表
-        let changedFiles = [];
-        try {
-            const resultJson = await readFile(join(taskDir, 'result.json'), 'utf-8');
-            const result = JSON.parse(resultJson);
-            changedFiles = result.changed_files ?? [];
-        }
-        catch {
-            // result.json 可能不存在
-        }
-        const sourceChatId = task?.source_ref
-            ? (getMessageLogBySourceRef(this.db, task.source_ref)?.chat_id ?? undefined)
-            : undefined;
-        return {
-            type: 'delivery',
-            taskId,
-            briefContent,
-            exitCode,
-            retryCount: task?.retry_count ?? 0,
-            maxRetries: task?.max_retries ?? 3,
-            prUrl: task?.pr_url ?? null,
-            changedFiles,
-            testResults,
-            originalMessage: task?.context ?? null,
-            chatId: task?.source_ref
-                ? (getMessageLogBySourceRef(this.db, task.source_ref)?.chat_id ?? null)
-                : null,
-            conversationId: null,
-            activeTasks: [],
-            sourceChatId,
-        };
-    }
-}
-//# sourceMappingURL=dispatcher.js.map

package/apps/server/dist/loid/intent-classifier.js

@@ -1,158 +0,0 @@
-import { IntentLevel } from '@team-anya/core';
-// ── 关键词列表 ──
-const TASK_VERBS = [
-    '修复', '优化', '排查', '添加', '实现', '删除', '重构', '升级',
-    'fix', 'add', 'implement', 'delete', 'remove', 'refactor', 'upgrade',
-    'optimize', 'debug', 'resolve', 'migrate',
-];
-const RISK_WORDS = [
-    '故障', '报警', '错误', '崩溃', '超时', '500', 'OOM', 'panic',
-    '宕机', '挂了', '异常', '告警', '失败', 'error', 'crash', 'timeout',
-    'fatal', 'outage', 'down',
-];
-const TECH_KEYWORDS = [
-    'React', 'Vue', 'Angular', 'TypeScript', 'JavaScript', 'Python', 'Go',
-    'PostgreSQL', 'MySQL', 'Redis', 'Docker', 'Kubernetes', 'API',
-    'GraphQL', 'REST', 'gRPC', 'CI/CD', 'Jenkins', 'GitHub',
-    'npm', 'pnpm', 'yarn', 'webpack', 'vite', 'Node.js',
-    'AWS', 'Azure', 'GCP', 'Linux', 'Nginx',
-];
-const ANYA_MENTION_PATTERN = /@anya\b/i;
-// 纯表情检测（Unicode Emoji + 常见 emoji 字符）
-const EMOJI_ONLY_PATTERN = /^[\s\p{Emoji_Presentation}\p{Extended_Pictographic}\u200d\ufe0f]*$/u;
-// ── IntentClassifier ──
-export class IntentClassifier {
-    orgLookup;
-    constructor(deps) {
-        this.orgLookup = deps.orgLookup;
-    }
-    /**
-     * 提取消息中的意图信号
-     */
-    extractSignals(message) {
-        const content = message.content;
-        const contentLower = content.toLowerCase();
-        const mentionsAnya = message.mentionsAnya === true || ANYA_MENTION_PATTERN.test(content);
-        const hasTaskVerbs = TASK_VERBS.some(verb => contentLower.includes(verb.toLowerCase()));
-        const hasRiskWords = RISK_WORDS.some(word => contentLower.includes(word.toLowerCase()));
-        const isDirectMessage = message.isDirectMessage === true;
-        return {
-            mentionsAnya,
-            hasTaskVerbs,
-            hasRiskWords,
-            senderHasOwnership: false, // 初始值，classify 中可能更新
-            isDirectMessage,
-        };
-    }
-    /**
-     * 判断是否为显式命令（@Anya + 任务动词）
-     */
-    isExplicitCommand(message) {
-        const signals = this.extractSignals(message);
-        return signals.mentionsAnya && signals.hasTaskVerbs;
-    }
-    /**
-     * 对消息进行意图分级
-     */
-    async classify(message) {
-        const content = message.content.trim();
-        const signals = this.extractSignals(message);
-        // 空消息或纯表情 → L0
-        if (content.length === 0 || this.isNoiseContent(content)) {
-            return {
-                level: IntentLevel.L0_NOISE,
-                confidence: 1.0,
-                signals,
-                suggestedAction: 'ignore',
-            };
-        }
-        // 尝试 orgLookup 查询 sender ownership
-        if (message.sender && this.orgLookup) {
-            try {
-                const orgInfo = await this.orgLookup(message.sender);
-                signals.senderHasOwnership = orgInfo.hasOwnership;
-            }
-            catch {
-                // orgLookup 不可用，安全降级
-                signals.senderHasOwnership = false;
-            }
-        }
-        // 规则优先判定
-        // 显式命令 → L3_COMMITMENT
-        if (signals.mentionsAnya && (signals.hasTaskVerbs || signals.hasRiskWords)) {
-            return {
-                level: IntentLevel.L3_COMMITMENT,
-                confidence: 0.95,
-                signals,
-                suggestedAction: 'create_task',
-            };
-        }
-        // 私聊 + 任务动词 → L3_COMMITMENT
-        if (signals.isDirectMessage && (signals.hasTaskVerbs || signals.hasRiskWords)) {
-            return {
-                level: IntentLevel.L3_COMMITMENT,
-                confidence: 0.9,
-                signals,
-                suggestedAction: 'create_task',
-            };
-        }
-        // sender 有 ownership + 任务动词 → L3_COMMITMENT
-        if (signals.senderHasOwnership && signals.hasTaskVerbs) {
-            return {
-                level: IntentLevel.L3_COMMITMENT,
-                confidence: 0.85,
-                signals,
-                suggestedAction: 'create_task',
-            };
-        }
-        // 有风险词或任务动词（但非显式命令）→ L2_OPPORTUNITY
-        if (signals.hasRiskWords || signals.hasTaskVerbs) {
-            return {
-                level: IntentLevel.L2_OPPORTUNITY,
-                confidence: 0.7,
-                signals,
-                suggestedAction: 'create_opportunity',
-            };
-        }
-        // 包含技术关键词 → L1_CONTEXT
-        if (this.hasTechContent(content)) {
-            return {
-                level: IntentLevel.L1_CONTEXT,
-                confidence: 0.6,
-                signals,
-                suggestedAction: 'cache_context',
-            };
-        }
-        // 默认 → L0_NOISE
-        return {
-            level: IntentLevel.L0_NOISE,
-            confidence: 0.5,
-            signals,
-            suggestedAction: 'ignore',
-        };
-    }
-    /**
-     * 判断内容是否为噪音（纯表情、纯标点、过短）
-     */
-    isNoiseContent(content) {
-        // 纯表情
-        if (EMOJI_ONLY_PATTERN.test(content))
-            return true;
-        // 纯标点符号和空格
-        if (/^[\s\p{P}]+$/u.test(content))
-            return true;
-        // 非常短且无有意义词汇（2 个字符以下）
-        const stripped = content.replace(/[\s\p{P}]/gu, '');
-        if (stripped.length <= 2 && !TASK_VERBS.some(v => content.toLowerCase().includes(v.toLowerCase()))) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * 判断内容是否包含技术相关词汇
-     */
-    hasTechContent(content) {
-        return TECH_KEYWORDS.some(keyword => content.toLowerCase().includes(keyword.toLowerCase()));
-    }
-}
-//# sourceMappingURL=intent-classifier.js.map