autosnippet 3.3.7 → 3.3.8

package/dist/lib/repository/knowledge/KnowledgeRepository.impl.js

@@ -1,10 +1,12 @@
-import { and, eq, sql } from 'drizzle-orm';
+import { and, count, desc, eq, gt, inArray, isNotNull, like, ne, or, sql } from 'drizzle-orm';
 import { inferKind, KnowledgeEntry } from '../../domain/knowledge/index.js';
+import { COUNTABLE_LIFECYCLES } from '../../domain/knowledge/Lifecycle.js';
 import { getDrizzle } from '../../infrastructure/database/drizzle/index.js';
 import { knowledgeEntries } from '../../infrastructure/database/drizzle/schema.js';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { safeJsonParse, safeJsonStringify, unixNow } from '../../shared/utils/common.js';
-import { BaseRepository } from '../base/BaseRepository.js';
+/** Only allow safe SQL identifier characters */
+const SAFE_IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 /**
  * KnowledgeRepositoryImpl — 统一知识实体仓储实现 (Drizzle ORM)
  *
@@ -15,14 +17,62 @@ import { BaseRepository } from '../base/BaseRepository.js';
  * - CRUD (create/findById/update/delete/findActiveRules) → drizzle 类型安全 API
  * - 复杂动态查询 (findWithPagination/getStats) → 保留 raw SQL→渐进迁移
  */
-export class KnowledgeRepositoryImpl extends BaseRepository {
+export class KnowledgeRepositoryImpl {
+    /** Raw DB for complex dynamic queries (ORM limitation — used within repository layer) */
+    db;
+    logger;
     #drizzle;
+    /** Lazily-populated column whitelist for SQL-injection prevention */
+    #columnWhitelist = null;
     constructor(database, drizzle) {
-        super(database, 'knowledge_entries');
+        this.db = database.getDb();
         this.logger = Logger.getInstance();
         this.#drizzle = drizzle ?? getDrizzle();
     }
+    /**
+     * Validate column name is safe for SQL interpolation (copied from retired BaseRepository).
+     * Rejects anything that doesn't match /^[a-zA-Z_]\w*$/ or is not a real column.
+     */
+    _assertSafeColumn(key) {
+        if (!SAFE_IDENTIFIER_RE.test(key)) {
+            throw new Error(`Invalid column name: ${key}`);
+        }
+        if (!this.#columnWhitelist) {
+            try {
+                const cols = this.db
+                    .prepare('PRAGMA table_info(knowledge_entries)')
+                    .all();
+                this.#columnWhitelist = new Set(cols.map((c) => c.name));
+            }
+            catch {
+                this.#columnWhitelist = new Set();
+            }
+        }
+        if (this.#columnWhitelist.size > 0 && !this.#columnWhitelist.has(key)) {
+            throw new Error(`Unknown column "${key}" for table knowledge_entries`);
+        }
+    }
     /* ═══ CRUD ═══════════════════════════════════════════ */
+    /**
+     * 按 ID 查找
+     * ★ Drizzle 类型安全 SELECT
+     */
+    async findById(id) {
+        try {
+            const row = this.#drizzle
+                .select()
+                .from(knowledgeEntries)
+                .where(eq(knowledgeEntries.id, id))
+                .limit(1)
+                .get();
+            return row ? this._rowToEntity(row) : null;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error('Error finding knowledge entry by id', { id, error: message });
+            throw error;
+        }
+    }
     /**
      * 创建 KnowledgeEntry
      * ★ Drizzle 类型安全 INSERT — 列名拼写编译期检查
@@ -116,6 +166,30 @@ export class KnowledgeRepositoryImpl extends BaseRepository {
         }
     }
     /* ═══ 查询 ═══════════════════════════════════════════ */
+    /**
+     * 更新生命周期状态
+     * ★ Drizzle 类型安全 UPDATE — 供 RecipeLifecycleSupervisor / ProposalExecutor 使用
+     */
+    async updateLifecycle(id, lifecycle) {
+        const result = this.#drizzle
+            .update(knowledgeEntries)
+            .set({ lifecycle, updatedAt: unixNow() })
+            .where(eq(knowledgeEntries.id, id))
+            .run();
+        return result.changes > 0;
+    }
+    /**
+     * 更新 stats JSON 字段
+     * ★ Drizzle 类型安全 UPDATE — 供 HitRecorder / RecipeLifecycleSupervisor 使用
+     */
+    async updateStats(id, stats) {
+        const result = this.#drizzle
+            .update(knowledgeEntries)
+            .set({ stats: safeJsonStringify(stats), updatedAt: unixNow() })
+            .where(eq(knowledgeEntries.id, id))
+            .run();
+        return result.changes > 0;
+    }
     /**
      * 分页查询
      * @override
@@ -127,8 +201,15 @@ export class KnowledgeRepositoryImpl extends BaseRepository {
         const params = [];
         const { _tagLike, _search, lifecycle: lcFilter, ...normalFilters } = filters;
         if (lcFilter) {
-            conditions.push(`lifecycle = ?`);
-            params.push(lcFilter);
+            if (Array.isArray(lcFilter)) {
+                const placeholders = lcFilter.map(() => '?').join(', ');
+                conditions.push(`lifecycle IN (${placeholders})`);
+                params.push(...lcFilter);
+            }
+            else {
+                conditions.push(`lifecycle = ?`);
+                params.push(lcFilter);
+            }
         }
         for (const [key, value] of Object.entries(normalFilters)) {
             if (value == null) {
@@ -195,6 +276,123 @@ export class KnowledgeRepositoryImpl extends BaseRepository {
             throw error;
         }
     }
+    /**
+     * Guard 专用：active 的 rule + boundary-constraint
+     * ★ Phase 5b: supply guard.ts _loadRuleRecipes
+     */
+    async findActiveGuardRecipes() {
+        const rows = this.#drizzle
+            .select()
+            .from(knowledgeEntries)
+            .where(and(eq(knowledgeEntries.lifecycle, 'active'), or(eq(knowledgeEntries.kind, 'rule'), eq(knowledgeEntries.knowledgeType, 'boundary-constraint'))))
+            .all();
+        return rows
+            .map((row) => this._rowToEntity(row))
+            .filter(Boolean);
+    }
+    /**
+     * 按 source 字段查询 ID 列表
+     * ★ Phase 5b: supply ai.ts mock cleanup
+     */
+    async findIdsBySource(source) {
+        const rows = this.#drizzle
+            .select({ id: knowledgeEntries.id })
+            .from(knowledgeEntries)
+            .where(eq(knowledgeEntries.source, source))
+            .all();
+        return rows.map((r) => r.id);
+    }
+    /**
+     * 统计指定 lifecycle 集合中的条目数量
+     * ★ Phase 5b: supply recipes.ts pre-check
+     */
+    async countByLifecycles(lifecycles) {
+        const rows = this.#drizzle
+            .select({ cnt: count() })
+            .from(knowledgeEntries)
+            .where(inArray(knowledgeEntries.lifecycle, lifecycles))
+            .all();
+        return Number(rows[0]?.cnt ?? 0);
+    }
+    /**
+     * 查询指定 lifecycle 集合中的所有条目（不分页）
+     * ★ Phase 5c: supply Evolution domain services (ContradictionDetector, RedundancyAnalyzer, etc.)
+     */
+    async findAllByLifecycles(lifecycles) {
+        const rows = this.#drizzle
+            .select()
+            .from(knowledgeEntries)
+            .where(inArray(knowledgeEntries.lifecycle, lifecycles))
+            .all();
+        return rows
+            .map((row) => this._rowToEntity(row))
+            .filter(Boolean);
+    }
+    /**
+     * 查询指定 lifecycle + category 的条目（带 limit）
+     * ★ Phase 5c: supply ConsolidationAdvisor category-filtered query
+     */
+    async findAllByLifecyclesAndCategory(lifecycles, category, limit) {
+        const rows = this.#drizzle
+            .select()
+            .from(knowledgeEntries)
+            .where(and(inArray(knowledgeEntries.lifecycle, lifecycles), eq(knowledgeEntries.category, category)))
+            .limit(limit)
+            .all();
+        return rows
+            .map((row) => this._rowToEntity(row))
+            .filter(Boolean);
+    }
+    /**
+     * 查询指定 lifecycle 中 trigger 匹配前缀且排除指定 category 的条目
+     * ★ Phase 5c: supply ConsolidationAdvisor trigger-prefix fallback
+     */
+    async findByLifecyclesAndTriggerPrefix(lifecycles, excludeCategory, triggerPrefix, limit) {
+        const rows = this.#drizzle
+            .select()
+            .from(knowledgeEntries)
+            .where(and(inArray(knowledgeEntries.lifecycle, lifecycles), ne(knowledgeEntries.category, excludeCategory), like(knowledgeEntries.trigger, `${triggerPrefix}%`)))
+            .limit(limit)
+            .all();
+        return rows
+            .map((row) => this._rowToEntity(row))
+            .filter(Boolean);
+    }
+    /**
+     * 按 lifecycle 分组统计全部条目数量
+     * ★ Phase 5c: supply RecipeLifecycleSupervisor health summary
+     */
+    async countGroupByLifecycle() {
+        const rows = this.#drizzle
+            .select({
+            lifecycle: knowledgeEntries.lifecycle,
+            cnt: count(),
+        })
+            .from(knowledgeEntries)
+            .groupBy(knowledgeEntries.lifecycle)
+            .all();
+        const result = {};
+        for (const row of rows) {
+            result[row.lifecycle ?? ''] = Number(row.cnt);
+        }
+        return result;
+    }
+    /**
+     * 反向查找 relations JSON 中包含指定 nodeId 的条目
+     * ★ Phase 5b: supply structure.ts relation graph
+     */
+    async findByRelationLike(nodeId, excludeId) {
+        const rows = this.#drizzle
+            .select({
+            id: knowledgeEntries.id,
+            title: knowledgeEntries.title,
+            relations: knowledgeEntries.relations,
+        })
+            .from(knowledgeEntries)
+            .where(and(like(knowledgeEntries.relations, `%${nodeId}%`), ne(knowledgeEntries.id, excludeId)))
+            .all();
+        return rows.map((r) => ({ id: r.id, title: r.title ?? '', relations: r.relations ?? '{}' }));
+    }
     /** 根据语言查询 */
     async findByLanguage(language, pagination = {}) {
         return this.findWithPagination({ language }, pagination);
@@ -233,6 +431,306 @@ export class KnowledgeRepositoryImpl extends BaseRepository {
             throw error;
         }
     }
+    /**
+     * Find all entries with non-empty reasoning (for SourceRefReconciler)
+     * ★ Drizzle 类型安全 SELECT — 仅返回 id + reasoning
+     */
+    async findAllIdAndReasoning() {
+        const rows = this.#drizzle
+            .select({
+            id: knowledgeEntries.id,
+            reasoning: knowledgeEntries.reasoning,
+        })
+            .from(knowledgeEntries)
+            .where(and(sql `${knowledgeEntries.reasoning} IS NOT NULL`, sql `${knowledgeEntries.reasoning} != '{}'`))
+            .all();
+        return rows
+            .filter((r) => r.reasoning != null)
+            .map((r) => ({ id: r.id, reasoning: r.reasoning }));
+    }
+    /**
+     * Find sourceFile and reasoning for a single entry (for SourceRefReconciler.applyRepairs)
+     * ★ Drizzle 类型安全 SELECT — 仅返回 sourceFile + reasoning
+     */
+    async findSourceFileAndReasoning(id) {
+        const row = this.#drizzle
+            .select({
+            sourceFile: knowledgeEntries.sourceFile,
+            reasoning: knowledgeEntries.reasoning,
+        })
+            .from(knowledgeEntries)
+            .where(eq(knowledgeEntries.id, id))
+            .limit(1)
+            .get();
+        if (!row) {
+            return null;
+        }
+        return { sourceFile: row.sourceFile ?? null, reasoning: row.reasoning ?? null };
+    }
+    /**
+     * Update reasoning JSON field directly (for SourceRefReconciler.applyRepairs)
+     * ★ Drizzle 类型安全 UPDATE — 精确更新 reasoning + updatedAt
+     */
+    async updateReasoning(id, reasoning, updatedAt) {
+        const result = this.#drizzle
+            .update(knowledgeEntries)
+            .set({ reasoning, updatedAt })
+            .where(eq(knowledgeEntries.id, id))
+            .run();
+        return result.changes > 0;
+    }
+    /* ─── Panorama 域查询 (Phase 5e) ─── */
+    /**
+     * 获取活跃 Recipe 的元数据 (title, category, topicHint, kind)
+     * 用于 DimensionAnalyzer 维度分类分析
+     */
+    async findRecipeMetadata(lifecycles) {
+        const rows = this.#drizzle
+            .select({
+            title: knowledgeEntries.title,
+            category: knowledgeEntries.category,
+            topicHint: knowledgeEntries.topicHint,
+            kind: knowledgeEntries.kind,
+        })
+            .from(knowledgeEntries)
+            .where(inArray(knowledgeEntries.lifecycle, lifecycles))
+            .all();
+        return rows.map((r) => ({
+            title: r.title ?? '',
+            category: r.category ?? '',
+            topicHint: r.topicHint ?? '',
+            kind: r.kind ?? '',
+        }));
+    }
+    /**
+     * 按模块相关关键词搜索 Recipe (PanoramaService.#findModuleRecipes)
+     * @param lifecycles - 活跃生命周期
+     * @param moduleName - 模块名
+     * @param categories - 角色关联的分类列表
+     * @param limit - 结果上限
+     */
+    async findModuleRecipes(lifecycles, moduleName, categories, limit = 20) {
+        const conditions = [
+            or(like(knowledgeEntries.title, `%${moduleName}%`), like(knowledgeEntries.trigger, `%${moduleName}%`), ...categories.map((cat) => eq(knowledgeEntries.category, cat))),
+        ];
+        const rows = this.#drizzle
+            .select({
+            id: knowledgeEntries.id,
+            title: knowledgeEntries.title,
+            trigger: knowledgeEntries.trigger,
+            kind: knowledgeEntries.kind,
+        })
+            .from(knowledgeEntries)
+            .where(and(inArray(knowledgeEntries.lifecycle, lifecycles), ...conditions))
+            .orderBy(knowledgeEntries.lifecycle)
+            .limit(limit)
+            .all();
+        return rows.map((r) => ({
+            id: r.id ?? '',
+            title: r.title ?? '',
+            trigger: r.trigger ?? '',
+            kind: r.kind ?? '',
+        }));
+    }
+    /**
+     * 统计 COUNTABLE_LIFECYCLES 范围内的知识条目数 (PanoramaAggregator.#getProjectRecipeCount)
+     */
+    async countByCountableLifecycles() {
+        const rows = this.#drizzle
+            .select({ cnt: count() })
+            .from(knowledgeEntries)
+            .where(inArray(knowledgeEntries.lifecycle, COUNTABLE_LIFECYCLES))
+            .all();
+        return Number(rows[0]?.cnt ?? 0);
+    }
+    /* ═══ Guard / Skills 用查询 ═══════════════════════════ */
+    /**
+     * Guard 规则查询 — kind='rule' OR knowledgeType='boundary-constraint' + lifecycle 过滤
+     * (GuardCheckEngine._loadCustomRules)
+     */
+    findGuardRulesSync(lifecycles) {
+        return this.#drizzle
+            .select({
+            id: knowledgeEntries.id,
+            title: knowledgeEntries.title,
+            description: knowledgeEntries.description,
+            language: knowledgeEntries.language,
+            scope: knowledgeEntries.scope,
+            constraints: knowledgeEntries.constraints,
+            lifecycle: knowledgeEntries.lifecycle,
+        })
+            .from(knowledgeEntries)
+            .where(and(or(eq(knowledgeEntries.kind, 'rule'), eq(knowledgeEntries.knowledgeType, 'boundary-constraint')), inArray(knowledgeEntries.lifecycle, lifecycles)))
+            .all();
+    }
+    /**
+     * Guard 命中次数递增 — stats.guardHits += count
+     * (GuardCheckEngine._recordHits)
+     */
+    incrementGuardHitsSync(id, hits) {
+        this.#drizzle
+            .update(knowledgeEntries)
+            .set({
+            stats: sql `json_set(COALESCE(${knowledgeEntries.stats}, '{}'), '$.guardHits', COALESCE(json_extract(${knowledgeEntries.stats}, '$.guardHits'), 0) + ${hits})`,
+            updatedAt: unixNow(),
+        })
+            .where(eq(knowledgeEntries.id, id))
+            .run();
+    }
+    /**
+     * 活跃规则 + content 中的 coreCode / pattern 字段 + stats
+     * (ReverseGuard.#loadActiveRules)
+     */
+    findActiveRulesWithContentSync() {
+        return this.#drizzle
+            .select({
+            id: knowledgeEntries.id,
+            title: knowledgeEntries.title,
+            coreCode: sql `json_extract(${knowledgeEntries.content}, '$.coreCode')`.as('coreCode'),
+            guardPattern: sql `json_extract(${knowledgeEntries.content}, '$.pattern')`.as('guardPattern'),
+            stats: knowledgeEntries.stats,
+        })
+            .from(knowledgeEntries)
+            .where(and(eq(knowledgeEntries.lifecycle, 'active'), eq(knowledgeEntries.kind, 'rule')))
+            .all();
+    }
+    /**
+     * 获取单条记录的 guardHits 数
+     * (ReverseGuard.#historicalGuardHits)
+     */
+    getGuardHitsSync(id) {
+        const row = this.#drizzle
+            .select({
+            hits: sql `json_extract(${knowledgeEntries.stats}, '$.guardHits')`.as('hits'),
+        })
+            .from(knowledgeEntries)
+            .where(eq(knowledgeEntries.id, id))
+            .get();
+        return Number(row?.hits ?? 0);
+    }
+    /**
+     * 活跃规则的 id + language (CoverageAnalyzer.#loadActiveRules) — sync
+     */
+    findActiveRuleIdsSync() {
+        return this.#drizzle
+            .select({
+            id: knowledgeEntries.id,
+            language: knowledgeEntries.language,
+        })
+            .from(knowledgeEntries)
+            .where(and(eq(knowledgeEntries.lifecycle, 'active'), eq(knowledgeEntries.kind, 'rule')))
+            .all();
+    }
+    /**
+     * 活跃条目按 category 分布
+     * (SkillAdvisor.#getKBDistribution)
+     */
+    async countGroupByCategory() {
+        return this.#drizzle
+            .select({
+            category: knowledgeEntries.category,
+            cnt: count(),
+        })
+            .from(knowledgeEntries)
+            .where(and(eq(knowledgeEntries.lifecycle, 'active'), isNotNull(knowledgeEntries.category), ne(knowledgeEntries.category, '')))
+            .groupBy(knowledgeEntries.category)
+            .orderBy(desc(count()))
+            .all();
+    }
+    /**
+     * 活跃条目按 language 分布
+     * (SkillAdvisor.#getKBDistribution)
+     */
+    async countGroupByLanguage() {
+        return this.#drizzle
+            .select({
+            language: knowledgeEntries.language,
+            cnt: count(),
+        })
+            .from(knowledgeEntries)
+            .where(and(eq(knowledgeEntries.lifecycle, 'active'), isNotNull(knowledgeEntries.language), ne(knowledgeEntries.language, '')))
+            .groupBy(knowledgeEntries.language)
+            .orderBy(desc(count()))
+            .all();
+    }
+    /**
+     * 高使用率活跃 Recipe (adoptions + applications >= minUsage)
+     * (SkillAdvisor.#getKBDistribution)
+     */
+    async findHotRecipesByUsage(minUsage, limit) {
+        return this.#drizzle
+            .select({
+            title: knowledgeEntries.title,
+            category: knowledgeEntries.category,
+            totalUsage: sql `(COALESCE(json_extract(${knowledgeEntries.stats}, '$.adoptions'), 0) + COALESCE(json_extract(${knowledgeEntries.stats}, '$.applications'), 0))`.as('totalUsage'),
+        })
+            .from(knowledgeEntries)
+            .where(and(eq(knowledgeEntries.lifecycle, 'active'), sql `(COALESCE(json_extract(${knowledgeEntries.stats}, '$.adoptions'), 0) + COALESCE(json_extract(${knowledgeEntries.stats}, '$.applications'), 0)) >= ${minUsage}`))
+            .orderBy(desc(sql `(COALESCE(json_extract(${knowledgeEntries.stats}, '$.adoptions'), 0) + COALESCE(json_extract(${knowledgeEntries.stats}, '$.applications'), 0))`))
+            .limit(limit)
+            .all();
+    }
+    /**
+     * 全库生命周期统计 (total / pending / deprecated)
+     * (SkillAdvisor.#getKBDistribution)
+     */
+    async getLifecycleCounts() {
+        const row = this.#drizzle
+            .select({
+            total: count(),
+            pending: sql `SUM(CASE WHEN ${knowledgeEntries.lifecycle} = 'pending' THEN 1 ELSE 0 END)`.as('pending'),
+            deprecated: sql `SUM(CASE WHEN ${knowledgeEntries.lifecycle} = 'deprecated' THEN 1 ELSE 0 END)`.as('deprecated'),
+        })
+            .from(knowledgeEntries)
+            .get();
+        return {
+            total: Number(row?.total ?? 0),
+            pending: Number(row?.pending ?? 0),
+            deprecated: Number(row?.deprecated ?? 0),
+        };
+    }
+    /**
+     * 活跃 Recipe 信号 (SignalCollector.#collectRecipeSignals)
+     */
+    async findActiveRecipeSignals(limit) {
+        return this.#drizzle
+            .select({
+            id: knowledgeEntries.id,
+            title: knowledgeEntries.title,
+            knowledgeType: knowledgeEntries.knowledgeType,
+            category: knowledgeEntries.category,
+            language: knowledgeEntries.language,
+            adoptionCount: sql `json_extract(${knowledgeEntries.stats}, '$.adoptions')`.as('adoptionCount'),
+            applicationCount: sql `json_extract(${knowledgeEntries.stats}, '$.applications')`.as('applicationCount'),
+            qualityOverall: sql `json_extract(${knowledgeEntries.quality}, '$.overall')`.as('qualityOverall'),
+            updatedAt: knowledgeEntries.updatedAt,
+        })
+            .from(knowledgeEntries)
+            .where(eq(knowledgeEntries.lifecycle, 'active'))
+            .orderBy(desc(knowledgeEntries.updatedAt))
+            .limit(limit)
+            .all();
+    }
+    /**
+     * 待审核 Candidate (SignalCollector.#collectCandidateSignals)
+     */
+    async findPendingCandidates(limit) {
+        return this.#drizzle
+            .select({
+            id: knowledgeEntries.id,
+            source: knowledgeEntries.source,
+            status: knowledgeEntries.lifecycle,
+            language: knowledgeEntries.language,
+            category: knowledgeEntries.category,
+            title: knowledgeEntries.title,
+            createdAt: knowledgeEntries.createdAt,
+        })
+            .from(knowledgeEntries)
+            .where(eq(knowledgeEntries.lifecycle, 'pending'))
+            .orderBy(desc(knowledgeEntries.createdAt))
+            .limit(limit)
+            .all();
+    }
     /* ═══ 行 ↔ 实体 映射 ═══════════════════════════════ */
     /** DB Row → KnowledgeEntry (camelCase 列名 = 属性名，直传) */
     _rowToEntity(row) {
@@ -257,7 +755,7 @@ export class KnowledgeRepositoryImpl extends BaseRepository {
             autoApprovable: !!row.autoApprovable,
             includeHeaders: !!row.includeHeaders,
             // Staging support
-            stagingDeadline: row.staging_deadline || null,
+            stagingDeadline: row.stagingDeadline || null,
         });
     }
     /** KnowledgeEntry → DB Row (camelCase 列名 = 属性名，直传) */
@@ -310,12 +808,109 @@ export class KnowledgeRepositoryImpl extends BaseRepository {
             staging_deadline: e.stagingDeadline || null,
         };
     }
-    /**
-     * 覆写 BaseRepository 的 _mapRowToEntity
-     * @override
-     */
-    _mapRowToEntity(row) {
-        return this._rowToEntity(row);
+    /* ═══════════════════════════════════════════════════════
+     *  SearchEngine 用同步方法
+     * ═══════════════════════════════════════════════════════ */
+    /** 查询所有非 deprecated 条目（buildIndex 用） */
+    findNonDeprecatedSync() {
+        return this.#drizzle
+            .select({
+            id: knowledgeEntries.id,
+            title: knowledgeEntries.title,
+            description: knowledgeEntries.description,
+            language: knowledgeEntries.language,
+            category: knowledgeEntries.category,
+            knowledgeType: knowledgeEntries.knowledgeType,
+            kind: knowledgeEntries.kind,
+            content: knowledgeEntries.content,
+            lifecycle: knowledgeEntries.lifecycle,
+            tags: knowledgeEntries.tags,
+            trigger: knowledgeEntries.trigger,
+            difficulty: knowledgeEntries.difficulty,
+            quality: knowledgeEntries.quality,
+            stats: knowledgeEntries.stats,
+            updatedAt: knowledgeEntries.updatedAt,
+            createdAt: knowledgeEntries.createdAt,
+        })
+            .from(knowledgeEntries)
+            .where(ne(knowledgeEntries.lifecycle, 'deprecated'))
+            .all();
+    }
+    /** LIKE 关键词搜索（_keywordSearch 用） */
+    keywordSearchSync(pattern, limit) {
+        return this.#drizzle
+            .select({
+            id: knowledgeEntries.id,
+            title: knowledgeEntries.title,
+            description: knowledgeEntries.description,
+            language: knowledgeEntries.language,
+            category: knowledgeEntries.category,
+            knowledgeType: knowledgeEntries.knowledgeType,
+            kind: knowledgeEntries.kind,
+            lifecycle: knowledgeEntries.lifecycle,
+            content: knowledgeEntries.content,
+            trigger: knowledgeEntries.trigger,
+            headers: knowledgeEntries.headers,
+            moduleName: knowledgeEntries.moduleName,
+        })
+            .from(knowledgeEntries)
+            .where(and(ne(knowledgeEntries.lifecycle, 'deprecated'), or(like(knowledgeEntries.title, pattern), like(knowledgeEntries.description, pattern), like(knowledgeEntries.trigger, pattern), like(knowledgeEntries.content, pattern))))
+            .limit(limit)
+            .all();
+    }
+    /** 按 ID 列表查询详情（_supplementDetails 用） */
+    findByIdsDetailSync(ids) {
+        if (ids.length === 0) {
+            return [];
+        }
+        return this.#drizzle
+            .select({
+            id: knowledgeEntries.id,
+            content: knowledgeEntries.content,
+            description: knowledgeEntries.description,
+            trigger: knowledgeEntries.trigger,
+            headers: knowledgeEntries.headers,
+            moduleName: knowledgeEntries.moduleName,
+            tags: knowledgeEntries.tags,
+            language: knowledgeEntries.language,
+            category: knowledgeEntries.category,
+            updatedAt: knowledgeEntries.updatedAt,
+            createdAt: knowledgeEntries.createdAt,
+            quality: knowledgeEntries.quality,
+            stats: knowledgeEntries.stats,
+            difficulty: knowledgeEntries.difficulty,
+            whenClause: knowledgeEntries.whenClause,
+            doClause: knowledgeEntries.doClause,
+        })
+            .from(knowledgeEntries)
+            .where(inArray(knowledgeEntries.id, ids))
+            .all();
+    }
+    /** 查询指定时间之后更新的条目（refreshIndex 用） */
+    findUpdatedSinceSync(sinceIso) {
+        const sinceEpoch = Math.floor(new Date(sinceIso).getTime() / 1000);
+        return this.#drizzle
+            .select({
+            id: knowledgeEntries.id,
+            title: knowledgeEntries.title,
+            description: knowledgeEntries.description,
+            language: knowledgeEntries.language,
+            category: knowledgeEntries.category,
+            knowledgeType: knowledgeEntries.knowledgeType,
+            kind: knowledgeEntries.kind,
+            content: knowledgeEntries.content,
+            lifecycle: knowledgeEntries.lifecycle,
+            tags: knowledgeEntries.tags,
+            trigger: knowledgeEntries.trigger,
+            difficulty: knowledgeEntries.difficulty,
+            quality: knowledgeEntries.quality,
+            stats: knowledgeEntries.stats,
+            updatedAt: knowledgeEntries.updatedAt,
+            createdAt: knowledgeEntries.createdAt,
+        })
+            .from(knowledgeEntries)
+            .where(gt(knowledgeEntries.updatedAt, sinceEpoch))
+            .all();
     }
 }
 export default KnowledgeRepositoryImpl;