feique 1.1.4 → 1.2.1

package/dist/bridge/service.js

@@ -37,7 +37,10 @@ import { classifyOperation, enforceTrustBoundary, recordRunOutcome, formatTrustS
 import { buildProjectTimeline, buildOnboardingContext, formatTimeline, isNewActor } from '../collaboration/timeline.js';
 import { HandoffStore } from '../state/handoff-store.js';
 import { TrustStore } from '../state/trust-store.js';
+import { IntentClassifier } from './intent-classifier.js';
 import { buildTeamDigest, formatTeamDigest, createDigestPeriod } from '../collaboration/digest.js';
+import { checkRunAlerts, checkLongRunningAlerts, formatAlert, DEFAULT_ALERT_RULES } from '../collaboration/proactive-alerts.js';
+import { detectKnowledgeGaps, formatKnowledgeGaps } from '../collaboration/knowledge-gaps.js';
 import { estimateCost } from '../observability/cost.js';
 export class FeiqueService {
     config;
@@ -62,6 +65,9 @@ export class FeiqueService {
     chatRateWindows = new Map();
     maintenanceTimer;
     digestTimer;
+    intentClassifier;
+    /** Tracks the current incoming message for @mention in replies. */
+    currentMessageContext;
     constructor(config, feishuClient, sessionStore, auditLog, logger, metrics, idempotencyStore = new IdempotencyStore(config.storage.dir), runStateStore = new RunStateStore(config.storage.dir), memoryStore = new MemoryStore(config.storage.dir), codexSessionIndex = new CodexSessionIndex(), runtimeControl, adminAuditLog = new AuditLog(config.storage.dir, 'admin-audit.jsonl'), configHistoryStore = new ConfigHistoryStore(config.storage.dir), handoffStore = new HandoffStore(config.storage.dir), trustStore = new TrustStore(config.storage.dir)) {
         this.config = config;
         this.feishuClient = feishuClient;
@@ -78,6 +84,20 @@ export class FeiqueService {
         this.configHistoryStore = configHistoryStore;
         this.handoffStore = handoffStore;
         this.trustStore = trustStore;
+        if (config.service.intent_classifier_enabled) {
+            const defaultBackend = config.backend?.default ?? 'codex';
+            const isClaude = defaultBackend === 'claude';
+            this.intentClassifier = new IntentClassifier({
+                enabled: true,
+                backend: defaultBackend,
+                backend_bin: isClaude ? (config.claude?.bin ?? 'claude') : config.codex.bin,
+                shell: isClaude ? config.claude?.shell : config.codex.shell,
+                pre_exec: isClaude ? config.claude?.pre_exec : config.codex.pre_exec,
+                ollama_base_url: config.embedding.provider === 'ollama' ? config.embedding.ollama_base_url : undefined,
+                timeout_ms: config.service.intent_classifier_timeout_ms,
+                min_confidence: config.service.intent_classifier_min_confidence,
+            });
+        }
     }
     async recoverRuntimeState() {
         const recovered = await this.runStateStore.recoverOrphanedRuns();
@@ -234,8 +254,25 @@ export class FeiqueService {
             await this.runMemoryMaintenance();
         }
         await this.runAuditMaintenance();
+        // Proactive: check for long-running tasks
+        try {
+            const activeRuns = await this.runStateStore.listRuns();
+            const longAlerts = checkLongRunningAlerts(activeRuns);
+            for (const alert of longAlerts) {
+                const text = formatAlert(alert);
+                for (const chatId of this.config.security.admin_chat_ids) {
+                    try {
+                        await this.feishuClient.sendText(chatId, text);
+                    }
+                    catch { /* best-effort */ }
+                }
+                await this.notifyProjectChats(alert.project_alias, text);
+            }
+        }
+        catch { /* best-effort */ }
     }
     async handleIncomingMessage(context) {
+        this.currentMessageContext = context;
         if (!context.text.trim() && context.attachments.length === 0) {
             return;
         }
@@ -263,7 +300,18 @@ export class FeiqueService {
         }
         const normalizedText = normalizeIncomingText(context.text);
         const selectionKey = await this.getSelectionConversationKey(context);
-        const command = parseBridgeCommand(context.text);
+        let command = parseBridgeCommand(context.text);
+        // AI intent fallback: when regex doesn't match, try AI classification
+        if (command.kind === 'prompt' && this.intentClassifier) {
+            try {
+                const aiCommand = await this.intentClassifier.classify(normalizedText);
+                if (aiCommand) {
+                    command = aiCommand;
+                    this.logger.info({ originalText: normalizedText, aiCommand: command.kind }, 'AI intent classifier matched');
+                }
+            }
+            catch { /* AI classification is best-effort */ }
+        }
         this.metrics?.recordIncomingMessage(context.chat_type, command.kind);
         await this.auditLog.append({
             type: 'message.received',
@@ -367,6 +415,9 @@ export class FeiqueService {
                     this.metrics?.recordCollaborationEvent('digest');
                     await this.handleDigestCommand(context);
                     return;
+                case 'gaps':
+                    await this.handleGapsCommand(context);
+                    return;
                 case 'prompt':
                     await this.handlePromptMessage(context, selectionKey, command.prompt, context.text);
                     return;
@@ -787,6 +838,14 @@ export class FeiqueService {
                 this.metrics?.recordTrustLevel(input.projectAlias, updated.current_level);
             }
             catch { /* trust tracking is best-effort */ }
+            // Proactive alerts: check if this run triggers any team alerts
+            try {
+                const completedRunState = await this.runStateStore.getRun(runId);
+                if (completedRunState) {
+                    await this.checkAndSendAlerts(completedRunState);
+                }
+            }
+            catch { /* alerts are best-effort */ }
             // Direction 2: Auto-extract knowledge
             if (this.config.service.memory_enabled && excerpt.length >= 100) {
                 try {
@@ -868,6 +927,14 @@ export class FeiqueService {
                 catch { /* trust tracking is best-effort */ }
                 // Notify project chats about the failure
                 await this.notifyProjectChats(input.projectAlias, `❌ 运行失败 [${input.projectAlias}]\n${message.slice(0, 200)}`);
+                // Proactive alerts on failure
+                try {
+                    const failedRunState = await this.runStateStore.getRun(runId);
+                    if (failedRunState) {
+                        await this.checkAndSendAlerts(failedRunState);
+                    }
+                }
+                catch { /* alerts are best-effort */ }
             }
             if (cancelled) {
                 this.logger.warn({
@@ -1473,6 +1540,44 @@ export class FeiqueService {
         const text = formatTeamDigest(digest);
         await this.sendTextReply(context.chat_id, text, context.message_id, context.text);
     }
+    // ── Proactive Alerts ──
+    async checkAndSendAlerts(completedRun) {
+        const recentRuns = await this.runStateStore.listRuns();
+        const projectConfig = this.config.projects[completedRun.project_alias];
+        const dailyQuota = projectConfig?.daily_token_quota;
+        const alerts = checkRunAlerts(completedRun, recentRuns, DEFAULT_ALERT_RULES, dailyQuota);
+        if (alerts.length === 0)
+            return;
+        for (const alert of alerts) {
+            const text = formatAlert(alert);
+            // Send to admin chat IDs
+            for (const chatId of this.config.security.admin_chat_ids) {
+                try {
+                    await this.feishuClient.sendText(chatId, text);
+                }
+                catch { /* best-effort */ }
+            }
+            // Send to project notification channels
+            await this.notifyProjectChats(alert.project_alias, text);
+            await this.auditLog.append({
+                type: 'collaboration.alert.sent',
+                alert_kind: alert.kind,
+                severity: alert.severity,
+                project_alias: alert.project_alias,
+                actor_id: alert.actor_id,
+            });
+        }
+    }
+    // ── Knowledge Gap Detection ──
+    async handleGapsCommand(context) {
+        const runs = await this.runStateStore.listRuns();
+        const memories = this.config.service.memory_enabled
+            ? await this.memoryStore.listRecentMemories({ scope: 'project', project_alias: '' }, 200)
+            : [];
+        const gaps = detectKnowledgeGaps(runs, memories);
+        const text = formatKnowledgeGaps(gaps);
+        await this.sendTextReply(context.chat_id, text, context.message_id, context.text);
+    }
     // ── Direction 6: Timeline ──
     async handleTimelineCommand(context, selectionKey, projectArg) {
         const projectContext = await this.resolveProjectContext(context, selectionKey);
@@ -3274,9 +3379,17 @@ export class FeiqueService {
             await this.sessionStore.dropProjectSession(conversationKey, projectAlias, session.thread_id);
         }
     }
-    async sendTextReply(chatId, body, replyToMessageId, originalText, presentation) {
+    async sendTextReply(chatId, body, replyToMessageId, originalText, presentation, mentionActor) {
+        // In group chats, prepend @mention to the reply so the requester gets notified
+        const actor = mentionActor ?? this.currentMessageContext;
+        let mentionPrefix = '';
+        if (actor?.chat_type === 'group' && actor.actor_id) {
+            const displayName = actor.actor_name || actor.actor_id;
+            mentionPrefix = `<at user_id="${actor.actor_id}">${displayName}</at>\n`;
+        }
+        const bodyWithMention = mentionPrefix ? mentionPrefix + body : body;
         const title = this.buildReplyTitle(this.sanitizeUserVisibleReply(body));
-        const formattedBody = this.sanitizeUserVisibleReply(this.formatQuotedReply(body, originalText));
+        const formattedBody = this.sanitizeUserVisibleReply(this.formatQuotedReply(bodyWithMention, originalText));
         if (this.config.service.reply_mode === 'card') {
             const card = buildMessageCard({
                 title,
@@ -3318,7 +3431,7 @@ export class FeiqueService {
             return response;
         }
         if (this.config.service.reply_quote_user_message && replyToMessageId) {
-            const response = await this.feishuClient.sendText(chatId, this.sanitizeUserVisibleReply(body), { replyToMessageId });
+            const response = await this.feishuClient.sendText(chatId, this.sanitizeUserVisibleReply(bodyWithMention), { replyToMessageId });
             await this.auditLog.append({
                 type: 'message.replied',
                 chat_id: chatId,