autosnippet 3.3.6 → 3.3.8

package/dist/lib/http/routes/recipes.js

@@ -6,6 +6,7 @@
  * 此路由仅处理 Recipe 特有的批量 AI 操作。
  */
 import express from 'express';
+import { COUNTABLE_LIFECYCLES } from '../../domain/knowledge/Lifecycle.js';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { getServiceContainer } from '../../injection/ServiceContainer.js';
 const router = express.Router();
@@ -70,11 +71,17 @@ router.post('/discover-relations', async (req, res) => {
             data: { status: 'error', error: 'AgentFactory 不可用，请检查 AI Provider 配置' },
         });
     }
-    // 快速检查：至少需要 2 条活跃 Recipe
+    // Mock 模式下跳过 AI 关系发现
+    if (agentFactory.getAiProviderInfo?.()?.name === 'mock') {
+        return void res.json({
+            success: true,
+            data: { status: 'error', error: 'AI Provider 未配置，当前为 Mock 模式。请先配置 API Key。' },
+        });
+    }
+    // 快速检查：至少需要 2 条可消费 Recipe（active/staging/pending/evolving）
     try {
-        const knowledgeService = container.get('knowledgeService');
-        const { items = [], data = [] } = (await knowledgeService.list({ lifecycle: 'active' }, { page: 1, pageSize: 5 }));
-        const count = items.length || data.length;
+        const knowledgeRepo = container.get('knowledgeRepository');
+        const count = await knowledgeRepo.countByLifecycles(COUNTABLE_LIFECYCLES);
         if (count < 2) {
             return void res.json({
                 success: true,
@@ -86,7 +93,7 @@ router.post('/discover-relations', async (req, res) => {
         }
     }
     catch {
-        // 如果 list 失败，继续尝试（让 runTask 给出具体错误）
+        // 如果查询失败，继续尝试（让 runTask 给出具体错误）
     }
     // 重置并启动后台任务
     resetTask();
@@ -96,11 +103,62 @@ router.post('/discover-relations', async (req, res) => {
     (async () => {
         try {
             const result = await agentFactory.discoverRelations();
+            const relations = result.relations || [];
+            const analyzed = result.analyzed || 0;
+            // 将 AI 发现的关系写入知识图谱
+            // AI 返回的 from/to 是 Recipe 标题，需要解析为实际 ID
+            let written = 0;
+            if (relations.length > 0) {
+                try {
+                    const graphService = container.get('knowledgeGraphService');
+                    const knowledgeRepo = container.get('knowledgeRepository');
+                    // 缓存标题 → ID 映射，避免重复查询
+                    const titleToId = new Map();
+                    const resolveId = async (title) => {
+                        if (titleToId.has(title)) {
+                            return titleToId.get(title);
+                        }
+                        try {
+                            const entry = await knowledgeRepo.findByTitle(title);
+                            const id = entry?.id ?? null;
+                            titleToId.set(title, id);
+                            return id;
+                        }
+                        catch {
+                            titleToId.set(title, null);
+                            return null;
+                        }
+                    };
+                    for (const rel of relations) {
+                        if (!rel.from || !rel.to || !rel.type) {
+                            continue;
+                        }
+                        const fromId = await resolveId(rel.from);
+                        const toId = await resolveId(rel.to);
+                        if (!fromId || !toId) {
+                            continue;
+                        }
+                        const res = await graphService.addEdge(fromId, 'recipe', toId, 'recipe', rel.type, {
+                            weight: 0.7,
+                            source: 'ai-discovery',
+                            evidence: rel.evidence || '',
+                        });
+                        if (res.success) {
+                            written++;
+                        }
+                    }
+                }
+                catch (graphErr) {
+                    logger.warn('Failed to write some discovered edges', {
+                        error: graphErr.message,
+                    });
+                }
+            }
             discoverTask.status = 'done';
             discoverTask.finishedAt = new Date().toISOString();
-            discoverTask.discovered = result.discovered || 0;
-            discoverTask.totalPairs = result.totalPairs || 0;
-            discoverTask.batchErrors = result.batchErrors || 0;
+            discoverTask.discovered = written;
+            discoverTask.totalPairs = analyzed;
+            discoverTask.batchErrors = relations.length - written;
             discoverTask.elapsed = Math.round((new Date(discoverTask.finishedAt).getTime() - new Date(discoverTask.startedAt).getTime()) /
                 1000);
             logger.info('Discover relations completed', {

package/dist/lib/http/routes/remote.js

@@ -21,7 +21,6 @@ import express from 'express';
 import { LarkTransport } from '../../external/lark/LarkTransport.js';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { getServiceContainer } from '../../injection/ServiceContainer.js';
-import { RemoteCommandRepository, } from '../../repository/remote/RemoteCommandRepository.js';
 import { resolveProjectRoot } from '../../shared/resolveProjectRoot.js';
 import { RemoteHistoryQuery, RemoteNotifyBody, RemoteResultBody, RemoteSendBody, } from '../../shared/schemas/http-requests.js';
 import { validate, validateQuery } from '../middleware/validate.js';
@@ -32,19 +31,10 @@ const PENDING_TIMEOUT_SEC = 120; // pending 超过 2 分钟 → timeout
 const RUNNING_TIMEOUT_SEC = 600; // running 超过 10 分钟 → timeout
 const CLEANUP_INTERVAL_MS = 30_000; // 每 30 秒清理一次
 // ─── 数据库辅助 ─────────────────────────────────────
-function getDb() {
-    const container = getServiceContainer();
-    const database = container.get('database');
-    return typeof database?.getDb === 'function' ? database.getDb() : database;
-}
-let _repo = null;
-/** 获取或创建 RemoteCommandRepository 单例 */
+/** 从 DI 容器获取 RemoteCommandRepository */
 function getRepo() {
-    if (!_repo) {
-        const db = getDb();
-        _repo = new RemoteCommandRepository(db);
-    }
-    return _repo;
+    const container = getServiceContainer();
+    return container.get('remoteCommandRepository');
 }
 function genId() {
     return `rcmd_${Date.now().toString(36)}_${crypto.randomBytes(3).toString('hex')}`;

package/dist/lib/http/routes/search.js

@@ -98,8 +98,8 @@ router.get('/graph', validateQuery(GraphQuery), async (req, res) => {
         return void res.json({ success: true, data: { outgoing: [], incoming: [] } });
     }
     const edges = relation
-        ? graphService.getRelated(nodeId, nodeType, relation)
-        : graphService.getEdges(nodeId, nodeType, direction);
+        ? await graphService.getRelated(nodeId, nodeType, relation)
+        : await graphService.getEdges(nodeId, nodeType, direction);
     res.json({ success: true, data: edges });
 });
 /**
@@ -114,7 +114,7 @@ router.get('/graph/impact', validateQuery(GraphImpactQuery), async (req, res) =>
     if (!graphService) {
         return void res.json({ success: true, data: [] });
     }
-    const impact = graphService.getImpactAnalysis(nodeId, nodeType, maxDepth);
+    const impact = await graphService.getImpactAnalysis(nodeId, nodeType, maxDepth);
     res.json({ success: true, data: impact });
 });
 /**
@@ -129,9 +129,11 @@ router.get('/graph/all', async (req, res) => {
     if (!graphService) {
         return void res.json({ success: true, data: { edges: [], nodeLabels: {} } });
     }
-    // 只返回 recipe 类型的关系边；module 依赖已由 /spm/dep-graph 提供
-    const nodeType = String(req.query.nodeType || 'recipe');
-    const edges = graphService.getAllEdges(limit, nodeType === 'all' ? undefined : nodeType);
+    // 默认不过滤 nodeType，返回所有知识相关边（recipe + knowledge）
+    // 仅当显式指定 nodeType 时才过滤（module 类由 /spm/dep-graph 提供）
+    const rawNodeType = req.query.nodeType;
+    const nodeType = rawNodeType === 'all' ? undefined : rawNodeType || undefined;
+    const edges = await graphService.getAllEdges(limit, nodeType);
     // 收集节点 ID + 类型 → 按类型查标签
     const nodeMap = new Map(); // id → Set<type>
     for (const e of edges) {
@@ -183,8 +185,9 @@ router.get('/graph/stats', async (req, res) => {
             data: { totalEdges: 0, byRelation: {}, nodeTypes: [] },
         });
     }
-    const nodeType = String(req.query.nodeType || 'recipe');
-    const stats = graphService.getStats(nodeType === 'all' ? undefined : nodeType);
+    const rawStatsType = req.query.nodeType;
+    const statsNodeType = rawStatsType === 'all' ? undefined : rawStatsType || undefined;
+    const stats = await graphService.getStats(statsNodeType);
     res.json({ success: true, data: stats });
 });
 /**

package/dist/lib/http/utils/routeHelpers.js

@@ -3,13 +3,14 @@
  * 提取自各路由文件中的重复实现
  */
 import { KnowledgeEntry } from '../../domain/knowledge/KnowledgeEntry.js';
+import { getDeveloperIdentity } from '../../shared/developer-identity.js';
 /**
  * 从请求中提取操作上下文（用户身份、IP、UA）
  * @returns }
  */
 export function getContext(req) {
     return {
-        userId: String(req.headers['x-user-id'] || 'anonymous'),
+        userId: String(req.headers['x-user-id'] || getDeveloperIdentity()),
         ip: req.ip || '',
         userAgent: req.headers['user-agent'] || '',
     };

package/dist/lib/infrastructure/audit/AuditLogger.d.ts

@@ -41,7 +41,18 @@ export declare class AuditLogger {
         startDate?: number;
         endDate?: number;
         limit?: number;
-    }): Promise<unknown[]>;
+    }): Promise<{
+        id: string;
+        timestamp: number;
+        actor: string;
+        actorContext: string | null;
+        action: string;
+        resource: string | null;
+        operationData: string | null;
+        result: string;
+        errorMessage: string | null;
+        duration: number | null;
+    }[]>;
     /** 获取特定请求的日志 */
     getByRequestId(requestId: string): Promise<{
         id: string;
@@ -102,8 +113,14 @@ export declare class AuditLogger {
         failure: number;
         successRate: string;
         avgDuration: string;
-        byActor: unknown[];
-        byAction: unknown[];
+        byActor: {
+            actor: string;
+            count: number;
+        }[];
+        byAction: {
+            action: string;
+            count: number;
+        }[];
     }>;
 }
 export default AuditLogger;

package/dist/lib/infrastructure/audit/AuditStore.d.ts

@@ -1,14 +1,10 @@
 import type { DrizzleDB } from '../database/drizzle/index.js';
 export declare class AuditStore {
     #private;
-    db: import('better-sqlite3').Database;
     constructor(db: {
         getDb: () => import('better-sqlite3').Database;
     }, drizzle?: DrizzleDB);
-    /**
-     * 保存审计日志
-     * ★ Drizzle 类型安全 INSERT
-     */
+    /** 保存审计日志 */
     save(entry: {
         id: string;
         timestamp: number;
@@ -21,7 +17,7 @@ export declare class AuditStore {
         error_message: string | null;
         duration: number | null;
     }): Promise<void>;
-    /** 查询审计日志 */
+    /** 查询审计日志（动态多条件，全 Drizzle） */
     query(filters?: {
         actor?: string;
         action?: string;
@@ -29,11 +25,19 @@ export declare class AuditStore {
         startDate?: number;
         endDate?: number;
         limit?: number;
-    }): unknown[];
-    /**
-     * 根据请求 ID 查询
-     * ★ Drizzle 类型安全 SELECT
-     */
+    }): {
+        id: string;
+        timestamp: number;
+        actor: string;
+        actorContext: string | null;
+        action: string;
+        resource: string | null;
+        operationData: string | null;
+        result: string;
+        errorMessage: string | null;
+        duration: number | null;
+    }[];
+    /** 根据请求 ID 查询 */
     findByRequestId(requestId: string): {
         id: string;
         timestamp: number;
@@ -46,10 +50,7 @@ export declare class AuditStore {
         errorMessage: string | null;
         duration: number | null;
     } | undefined;
-    /**
-     * 根据角色查询
-     * ★ Drizzle 类型安全 SELECT
-     */
+    /** 根据角色查询 */
     findByActor(actor: string, limit?: number): {
         id: string;
         timestamp: number;
@@ -62,10 +63,7 @@ export declare class AuditStore {
         errorMessage: string | null;
         duration: number | null;
     }[];
-    /**
-     * 根据操作查询
-     * ★ Drizzle 类型安全 SELECT
-     */
+    /** 根据操作查询 */
     findByAction(action: string, limit?: number): {
         id: string;
         timestamp: number;
@@ -78,10 +76,7 @@ export declare class AuditStore {
         errorMessage: string | null;
         duration: number | null;
     }[];
-    /**
-     * 根据结果查询
-     * ★ Drizzle 类型安全 SELECT
-     */
+    /** 根据结果查询 */
     findByResult(result: string, limit?: number): {
         id: string;
         timestamp: number;
@@ -94,7 +89,7 @@ export declare class AuditStore {
         errorMessage: string | null;
         duration: number | null;
     }[];
-    /** 获取统计数据 */
+    /** 获取统计数据（全 Drizzle） */
     getStats(timeRange?: string): {
         timeRange: string;
         total: number;
@@ -102,14 +97,18 @@ export declare class AuditStore {
         failure: number;
         successRate: string;
         avgDuration: string;
-        byActor: unknown[];
-        byAction: unknown[];
+        byActor: {
+            actor: string;
+            count: number;
+        }[];
+        byAction: {
+            action: string;
+            count: number;
+        }[];
     };
     /**
      * 清理过期审计日志
-     * ★ Drizzle 类型安全 DELETE
-     * @param [opts.maxAgeDays=90] 保留天数，超过此天数的记录将被删除
-     * @returns }
+     * @param [opts.maxAgeDays=90] 保留天数
      */
     cleanup({ maxAgeDays }?: {
         maxAgeDays?: number | undefined;

package/dist/lib/infrastructure/audit/AuditStore.js

@@ -1,18 +1,13 @@
-/** AuditStore - 审计日志存储 */
-import { desc, eq, sql } from 'drizzle-orm';
+/** AuditStore - 审计日志存储（全 Drizzle 类型安全） */
+import { and, avg, count, desc, eq, gte, lte, sql } from 'drizzle-orm';
 import { getDrizzle } from '../database/drizzle/index.js';
 import { auditLogs } from '../database/drizzle/schema.js';
 export class AuditStore {
-    db;
     #drizzle;
     constructor(db, drizzle) {
-        this.db = db.getDb();
         this.#drizzle = drizzle ?? getDrizzle();
     }
-    /**
-     * 保存审计日志
-     * ★ Drizzle 类型安全 INSERT
-     */
+    /** 保存审计日志 */
     async save(entry) {
         this.#drizzle
             .insert(auditLogs)
@@ -30,49 +25,40 @@ export class AuditStore {
         })
             .run();
     }
-    /** 查询审计日志 */
+    /** 查询审计日志（动态多条件，全 Drizzle） */
     query(filters = {}) {
-        let sql = 'SELECT * FROM audit_logs WHERE 1=1';
-        const params = [];
+        const conditions = [];
         if (filters.actor) {
-            sql += ' AND actor = ?';
-            params.push(filters.actor);
+            conditions.push(eq(auditLogs.actor, filters.actor));
         }
         if (filters.action) {
-            sql += ' AND action = ?';
-            params.push(filters.action);
+            conditions.push(eq(auditLogs.action, filters.action));
         }
         if (filters.result) {
-            sql += ' AND result = ?';
-            params.push(filters.result);
+            conditions.push(eq(auditLogs.result, filters.result));
         }
         if (filters.startDate) {
-            sql += ' AND timestamp >= ?';
-            params.push(filters.startDate);
+            conditions.push(gte(auditLogs.timestamp, filters.startDate));
         }
         if (filters.endDate) {
-            sql += ' AND timestamp <= ?';
-            params.push(filters.endDate);
+            conditions.push(lte(auditLogs.timestamp, filters.endDate));
         }
-        sql += ' ORDER BY timestamp DESC';
+        const condition = conditions.length > 0 ? and(...conditions) : undefined;
+        let query = this.#drizzle
+            .select()
+            .from(auditLogs)
+            .where(condition)
+            .orderBy(desc(auditLogs.timestamp));
         if (filters.limit) {
-            sql += ' LIMIT ?';
-            params.push(filters.limit);
+            query = query.limit(filters.limit);
         }
-        const stmt = this.db.prepare(sql);
-        return stmt.all(...params);
+        return query.all();
     }
-    /**
-     * 根据请求 ID 查询
-     * ★ Drizzle 类型安全 SELECT
-     */
+    /** 根据请求 ID 查询 */
     findByRequestId(requestId) {
         return this.#drizzle.select().from(auditLogs).where(eq(auditLogs.id, requestId)).get();
     }
-    /**
-     * 根据角色查询
-     * ★ Drizzle 类型安全 SELECT
-     */
+    /** 根据角色查询 */
     findByActor(actor, limit = 100) {
         return this.#drizzle
             .select()
@@ -82,10 +68,7 @@ export class AuditStore {
             .limit(limit)
             .all();
     }
-    /**
-     * 根据操作查询
-     * ★ Drizzle 类型安全 SELECT
-     */
+    /** 根据操作查询 */
     findByAction(action, limit = 100) {
         return this.#drizzle
             .select()
@@ -95,10 +78,7 @@ export class AuditStore {
             .limit(limit)
             .all();
     }
-    /**
-     * 根据结果查询
-     * ★ Drizzle 类型安全 SELECT
-     */
+    /** 根据结果查询 */
     findByResult(result, limit = 100) {
         return this.#drizzle
             .select()
@@ -108,66 +88,79 @@ export class AuditStore {
             .limit(limit)
             .all();
     }
-    /** 获取统计数据 */
+    /** 获取统计数据（全 Drizzle） */
     getStats(timeRange = '24h') {
-        // 计算时间范围
         const hours = timeRange === '24h' ? 24 : timeRange === '7d' ? 168 : 720; // 30d
         const startTime = Date.now() - hours * 60 * 60 * 1000;
-        // 总数统计
-        const total = this.db
-            .prepare('SELECT COUNT(*) as count FROM audit_logs WHERE timestamp >= ?')
-            .get(startTime);
-        // 成功/失败统计
-        const successCount = this.db
-            .prepare("SELECT COUNT(*) as count FROM audit_logs WHERE timestamp >= ? AND result = 'success'")
-            .get(startTime);
-        const failureCount = this.db
-            .prepare("SELECT COUNT(*) as count FROM audit_logs WHERE timestamp >= ? AND result = 'failure'")
-            .get(startTime);
+        const startCondition = gte(auditLogs.timestamp, startTime);
+        // 总数
+        const [totalRow] = this.#drizzle
+            .select({ count: count() })
+            .from(auditLogs)
+            .where(startCondition)
+            .all();
+        const total = totalRow?.count ?? 0;
+        // 成功数
+        const [successRow] = this.#drizzle
+            .select({ count: count() })
+            .from(auditLogs)
+            .where(and(startCondition, eq(auditLogs.result, 'success')))
+            .all();
+        const successCount = successRow?.count ?? 0;
+        // 失败数
+        const [failureRow] = this.#drizzle
+            .select({ count: count() })
+            .from(auditLogs)
+            .where(and(startCondition, eq(auditLogs.result, 'failure')))
+            .all();
+        const failureCount = failureRow?.count ?? 0;
         // 按角色统计
-        const byActor = this.db
-            .prepare(`
-        SELECT actor, COUNT(*) as count
-        FROM audit_logs
-        WHERE timestamp >= ?
-        GROUP BY actor
-        ORDER BY count DESC
-      `)
-            .all(startTime);
+        const byActor = this.#drizzle
+            .select({
+            actor: auditLogs.actor,
+            count: count(),
+        })
+            .from(auditLogs)
+            .where(startCondition)
+            .groupBy(auditLogs.actor)
+            .orderBy(desc(count()))
+            .all();
         // 按操作统计
-        const byAction = this.db
-            .prepare(`
-        SELECT action, COUNT(*) as count
-        FROM audit_logs
-        WHERE timestamp >= ?
-        GROUP BY action
-        ORDER BY count DESC
-      `)
-            .all(startTime);
+        const byAction = this.#drizzle
+            .select({
+            action: auditLogs.action,
+            count: count(),
+        })
+            .from(auditLogs)
+            .where(startCondition)
+            .groupBy(auditLogs.action)
+            .orderBy(desc(count()))
+            .all();
         // 平均响应时间
-        const avgDuration = this.db
-            .prepare(`
-        SELECT AVG(duration) as avg_duration
-        FROM audit_logs
-        WHERE timestamp >= ? AND duration IS NOT NULL
-      `)
-            .get(startTime);
+        const [avgRow] = this.#drizzle
+            .select({
+            avg_duration: avg(auditLogs.duration),
+        })
+            .from(auditLogs)
+            .where(and(startCondition, sql `${auditLogs.duration} IS NOT NULL`))
+            .all();
+        const avgDuration = avgRow?.avg_duration
+            ? `${Math.round(Number(avgRow.avg_duration))}ms`
+            : 'N/A';
         return {
             timeRange,
-            total: total.count,
-            success: successCount.count,
-            failure: failureCount.count,
-            successRate: total.count > 0 ? `${((successCount.count / total.count) * 100).toFixed(2)}%` : '0%',
-            avgDuration: avgDuration.avg_duration ? `${Math.round(avgDuration.avg_duration)}ms` : 'N/A',
+            total,
+            success: successCount,
+            failure: failureCount,
+            successRate: total > 0 ? `${((successCount / total) * 100).toFixed(2)}%` : '0%',
+            avgDuration,
             byActor,
             byAction,
         };
     }
     /**
      * 清理过期审计日志
-     * ★ Drizzle 类型安全 DELETE
-     * @param [opts.maxAgeDays=90] 保留天数，超过此天数的记录将被删除
-     * @returns }
+     * @param [opts.maxAgeDays=90] 保留天数
      */
     cleanup({ maxAgeDays = 90 } = {}) {
         try {