autosnippet 3.3.6 → 3.3.8

package/dist/lib/injection/modules/InfraModule.js

@@ -16,7 +16,18 @@ import { EventBus } from '../../infrastructure/event/EventBus.js';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { getRealtimeService as _getRealtimeService } from '../../infrastructure/realtime/RealtimeService.js';
 import { ReportStore } from '../../infrastructure/report/ReportStore.js';
+import { AuditRepositoryImpl } from '../../repository/audit/AuditRepository.js';
+import { BootstrapRepositoryImpl } from '../../repository/bootstrap/BootstrapRepository.js';
+import { CodeEntityRepositoryImpl } from '../../repository/code/CodeEntityRepository.js';
+import { ProposalRepository } from '../../repository/evolution/ProposalRepository.js';
+import { GuardViolationRepositoryImpl } from '../../repository/guard/GuardViolationRepository.js';
+import { KnowledgeEdgeRepositoryImpl } from '../../repository/knowledge/KnowledgeEdgeRepository.js';
 import { KnowledgeRepositoryImpl } from '../../repository/knowledge/KnowledgeRepository.impl.js';
+import { MemoryRepositoryImpl } from '../../repository/memory/MemoryRepository.js';
+import { RemoteCommandRepository } from '../../repository/remote/RemoteCommandRepository.js';
+import { unwrapRawDb } from '../../repository/search/SearchRepoAdapter.js';
+import { SessionRepositoryImpl } from '../../repository/session/SessionRepository.js';
+import { RecipeSourceRefRepositoryImpl } from '../../repository/sourceref/RecipeSourceRefRepository.js';
 import { BootstrapTaskManager } from '../../service/bootstrap/BootstrapTaskManager.js';
 import { KnowledgeFileWriter } from '../../service/knowledge/KnowledgeFileWriter.js';
 export function register(c) {
@@ -59,6 +70,55 @@ export function register(c) {
         const drizzle = db.getDrizzle();
         return new KnowledgeRepositoryImpl(db, drizzle);
     });
+    c.singleton('knowledgeEdgeRepository', (ct) => {
+        const db = ct.get('database');
+        const drizzle = db.getDrizzle();
+        return new KnowledgeEdgeRepositoryImpl(drizzle);
+    });
+    c.singleton('codeEntityRepository', (ct) => {
+        const db = ct.get('database');
+        const drizzle = db.getDrizzle();
+        return new CodeEntityRepositoryImpl(drizzle);
+    });
+    c.singleton('bootstrapRepository', (ct) => {
+        const db = ct.get('database');
+        const drizzle = db.getDrizzle();
+        return new BootstrapRepositoryImpl(drizzle);
+    });
+    c.singleton('guardViolationRepository', (ct) => {
+        const db = ct.get('database');
+        const drizzle = db.getDrizzle();
+        return new GuardViolationRepositoryImpl(drizzle);
+    });
+    c.singleton('auditRepository', (ct) => {
+        const db = ct.get('database');
+        const drizzle = db.getDrizzle();
+        return new AuditRepositoryImpl(drizzle);
+    });
+    c.singleton('memoryRepository', (ct) => {
+        const db = ct.get('database');
+        const drizzle = db.getDrizzle();
+        return new MemoryRepositoryImpl(drizzle);
+    });
+    c.singleton('sessionRepository', (ct) => {
+        const db = ct.get('database');
+        const drizzle = db.getDrizzle();
+        return new SessionRepositoryImpl(drizzle);
+    });
+    c.singleton('proposalRepository', (ct) => {
+        const db = ct.get('database');
+        const drizzle = db.getDrizzle();
+        return new ProposalRepository(drizzle);
+    });
+    c.singleton('remoteCommandRepository', (ct) => {
+        const db = ct.get('database');
+        return new RemoteCommandRepository(unwrapRawDb(db), db.getDrizzle());
+    });
+    c.singleton('recipeSourceRefRepository', (ct) => {
+        const db = ct.get('database');
+        const drizzle = db.getDrizzle();
+        return new RecipeSourceRefRepositoryImpl(drizzle);
+    });
     c.singleton('knowledgeFileWriter', (ct) => {
         const projectRoot = resolveProjectRoot(ct);
         return new KnowledgeFileWriter(projectRoot);

package/dist/lib/injection/modules/KnowledgeModule.js

@@ -14,6 +14,7 @@ import { getEnhancementRegistry } from '../../core/enhancement/index.js';
 import { HnswVectorAdapter } from '../../infrastructure/vector/HnswVectorAdapter.js';
 import { IndexingPipeline } from '../../infrastructure/vector/IndexingPipeline.js';
 import { JsonVectorAdapter } from '../../infrastructure/vector/JsonVectorAdapter.js';
+import { LifecycleEventRepository } from '../../repository/evolution/LifecycleEventRepository.js';
 import { ProposalRepository } from '../../repository/evolution/ProposalRepository.js';
 import { ConsolidationAdvisor } from '../../service/evolution/ConsolidationAdvisor.js';
 import { ContentPatcher } from '../../service/evolution/ContentPatcher.js';
@@ -42,11 +43,13 @@ export function register(c) {
         confidenceRouter: ct.get('confidenceRouter'),
         qualityScorer: ct.get('qualityScorer'),
         eventBus: ct.services.eventBus ? ct.get('eventBus') : null,
+        edgeRepo: ct.get('knowledgeEdgeRepository'),
+        proposalRepo: ct.get('proposalRepository'),
     }));
-    c.singleton('knowledgeGraphService', (ct) => new KnowledgeGraphService(ct.get('database')));
+    c.singleton('knowledgeGraphService', (ct) => new KnowledgeGraphService(ct.get('knowledgeEdgeRepository')));
     c.singleton('codeEntityGraph', (ct) => {
         const projectRoot = resolveProjectRoot(ct);
-        return new CodeEntityGraph(ct.get('database'), { projectRoot });
+        return new CodeEntityGraph(ct.get('codeEntityRepository'), ct.get('knowledgeEdgeRepository'), { projectRoot });
     });
     // ═══ Search + Vector ═══
     c.singleton('searchEngine', (ct) => {
@@ -58,11 +61,10 @@ export function register(c) {
             vectorStore: ct.get('vectorStore'),
             vectorService,
             hybridRetriever: ct.get('hybridRetriever'),
-            // CrossEncoderReranker disabled — BM25+vector dual-recall + CoarseRanker + MultiSignalRanker
-            // is sufficient for knowledge-base scale (hundreds~thousands of entries).
-            // Re-enable when document scale grows to 10k+ or external noisy sources are integrated.
             crossEncoderReranker: null,
             signalBus: ct.singletons.signalBus || null,
+            knowledgeRepo: ct.get('knowledgeRepository'),
+            sourceRefRepo: ct.get('recipeSourceRefRepository'),
         });
     }, { aiDependent: true });
     c.singleton('vectorStore', (ct) => {
@@ -135,39 +137,47 @@ export function register(c) {
     c.register('projectGraph', () => c.singletons.projectGraph || null);
     // ═══ Governance / Evolution ═══
     c.singleton('sourceRefReconciler', (ct) => {
-        const db = ct.get('database');
         const projectRoot = resolveProjectRoot();
-        return new SourceRefReconciler(projectRoot, db.getDb(), {
+        const sourceRefRepo = ct.get('recipeSourceRefRepository');
+        const knowledgeRepo = ct.get('knowledgeRepository');
+        return new SourceRefReconciler(projectRoot, sourceRefRepo, knowledgeRepo, {
             signalBus: ct.singletons.signalBus || undefined,
         });
     });
     c.singleton('stagingManager', (ct) => {
-        const db = ct.get('database');
-        return new StagingManager(db.getDb(), {
+        const knowledgeRepo = ct.get('knowledgeRepository');
+        return new StagingManager(knowledgeRepo, {
             signalBus: ct.singletons.signalBus || undefined,
         });
     });
     c.singleton('decayDetector', (ct) => {
-        const db = ct.get('database');
-        return new DecayDetector(db.getDb(), {
+        const knowledgeRepo = ct.get('knowledgeRepository');
+        return new DecayDetector(knowledgeRepo, {
             signalBus: ct.singletons.signalBus || undefined,
+            knowledgeEdgeRepo: ct.services.knowledgeEdgeRepository
+                ? ct.get('knowledgeEdgeRepository')
+                : undefined,
+            sourceRefRepo: ct.services.recipeSourceRefRepository
+                ? ct.get('recipeSourceRefRepository')
+                : undefined,
+            drizzle: ct.get('database').getDrizzle(),
         });
     });
     c.singleton('contradictionDetector', (ct) => {
-        const db = ct.get('database');
-        return new ContradictionDetector(db.getDb(), {
+        const knowledgeRepo = ct.get('knowledgeRepository');
+        return new ContradictionDetector(knowledgeRepo, {
             signalBus: ct.singletons.signalBus || undefined,
         });
     });
     c.singleton('redundancyAnalyzer', (ct) => {
-        const db = ct.get('database');
-        return new RedundancyAnalyzer(db.getDb(), {
+        const knowledgeRepo = ct.get('knowledgeRepository');
+        return new RedundancyAnalyzer(knowledgeRepo, {
             signalBus: ct.singletons.signalBus || undefined,
         });
     });
     c.singleton('enhancementSuggester', (ct) => {
-        const db = ct.get('database');
-        return new EnhancementSuggester(db.getDb(), {
+        const knowledgeRepo = ct.get('knowledgeRepository');
+        return new EnhancementSuggester(knowledgeRepo, {
             signalBus: ct.singletons.signalBus || undefined,
         });
     });
@@ -184,29 +194,45 @@ export function register(c) {
     });
     c.singleton('proposalRepository', (ct) => {
         const db = ct.get('database');
-        return new ProposalRepository(db.getDb());
+        const drizzle = db.getDrizzle();
+        return new ProposalRepository(drizzle);
     });
     c.singleton('contentPatcher', (ct) => {
+        const knowledgeRepo = ct.get('knowledgeRepository');
+        const sourceRefRepo = ct.get('recipeSourceRefRepository');
+        return new ContentPatcher(knowledgeRepo, sourceRefRepo);
+    });
+    c.singleton('lifecycleEventRepository', (ct) => {
         const db = ct.get('database');
-        return new ContentPatcher(db.getDb());
+        const drizzle = db.getDrizzle();
+        return new LifecycleEventRepository(drizzle);
     });
     c.singleton('lifecycleSupervisor', (ct) => {
-        const db = ct.get('database');
-        return new RecipeLifecycleSupervisor(db.getDb(), {
+        const knowledgeRepo = ct.get('knowledgeRepository');
+        return new RecipeLifecycleSupervisor(knowledgeRepo, {
             signalBus: ct.singletons.signalBus || undefined,
+            lifecycleEventRepo: ct.services.lifecycleEventRepository
+                ? ct.get('lifecycleEventRepository')
+                : undefined,
+            proposalRepo: ct.services.proposalRepository
+                ? ct.get('proposalRepository')
+                : undefined,
         });
     });
     c.singleton('proposalExecutor', (ct) => {
-        const db = ct.get('database');
-        return new ProposalExecutor(db.getDb(), ct.get('proposalRepository'), {
+        const knowledgeRepo = ct.get('knowledgeRepository');
+        return new ProposalExecutor(knowledgeRepo, ct.get('proposalRepository'), {
             signalBus: ct.singletons.signalBus || undefined,
             contentPatcher: ct.get('contentPatcher'),
             supervisor: ct.get('lifecycleSupervisor'),
+            knowledgeEdgeRepo: ct.services.knowledgeEdgeRepository
+                ? ct.get('knowledgeEdgeRepository')
+                : undefined,
         });
     });
     c.singleton('consolidationAdvisor', (ct) => {
-        const db = ct.get('database');
-        return new ConsolidationAdvisor(db.getDb());
+        const knowledgeRepo = ct.get('knowledgeRepository');
+        return new ConsolidationAdvisor(knowledgeRepo);
     });
 }
 /**
@@ -235,7 +261,7 @@ export function initializeKnowledgeServices(c) {
             try {
                 const d = data;
                 if (d.action === 'create' && d.entryId) {
-                    _populateSourceRefsForEntry(c, d.entryId);
+                    void _populateSourceRefsForEntry(c, d.entryId);
                 }
             }
             catch {
@@ -256,36 +282,45 @@ function await_import_EventBus() {
 }
 /**
  * 从 knowledge_entries.reasoning 中提取 sources 并填充 recipe_source_refs 桥接表
+ * 使用 KnowledgeRepository + RecipeSourceRefRepository 类型安全 API
  */
-function _populateSourceRefsForEntry(c, entryId) {
-    const db = c.get('database');
-    const rawDb = db.getDb();
-    const row = rawDb.prepare(`SELECT reasoning FROM knowledge_entries WHERE id = ?`).get(entryId);
-    if (!row?.reasoning) {
-        return;
-    }
-    let sources = [];
+async function _populateSourceRefsForEntry(c, entryId) {
     try {
-        const reasoning = JSON.parse(row.reasoning);
-        sources = Array.isArray(reasoning.sources)
-            ? reasoning.sources.filter((s) => typeof s === 'string' && s.length > 0)
-            : [];
-    }
-    catch {
-        return;
-    }
-    if (sources.length === 0) {
-        return;
-    }
-    const now = Date.now();
-    const upsert = rawDb.prepare(`INSERT OR REPLACE INTO recipe_source_refs (recipe_id, source_path, status, verified_at)
-     VALUES (?, ?, 'active', ?)`);
-    for (const sourcePath of sources) {
+        const knowledgeRepo = c.get('knowledgeRepository');
+        const sourceRefRepo = c.get('recipeSourceRefRepository');
+        const row = await knowledgeRepo.findSourceFileAndReasoning(entryId);
+        if (!row?.reasoning) {
+            return;
+        }
+        let sources = [];
         try {
-            upsert.run(entryId, sourcePath, now);
+            const reasoning = JSON.parse(row.reasoning);
+            sources = Array.isArray(reasoning.sources)
+                ? reasoning.sources.filter((s) => typeof s === 'string' && s.length > 0)
+                : [];
         }
         catch {
-            /* table may not exist yet */
+            return;
+        }
+        if (sources.length === 0) {
+            return;
         }
+        const now = Date.now();
+        for (const sourcePath of sources) {
+            try {
+                sourceRefRepo.upsert({
+                    recipeId: entryId,
+                    sourcePath,
+                    status: 'active',
+                    verifiedAt: now,
+                });
+            }
+            catch {
+                /* table may not exist yet */
+            }
+        }
+    }
+    catch {
+        /* repos may not be registered yet */
     }
 }

package/dist/lib/injection/modules/PanoramaModule.js

@@ -23,16 +23,16 @@ import { RoleRefiner } from '../../service/panorama/RoleRefiner.js';
 export const PanoramaModule = {
     register(container) {
         const ct = container;
-        const getDb = () => {
-            const db = ct.singletons.database;
-            return (db?.getDb ? db.getDb() : db);
-        };
         const getProjectRoot = () => ct.config?.projectRoot ?? process.cwd();
-        ct.singleton('moduleDiscoverer', () => new ModuleDiscoverer(getDb(), getProjectRoot()));
-        ct.singleton('roleRefiner', () => new RoleRefiner(getDb(), getProjectRoot()));
-        ct.singleton('couplingAnalyzer', () => new CouplingAnalyzer(getDb(), getProjectRoot()));
+        const getBootstrapRepo = () => container.get('bootstrapRepository');
+        const getEntityRepo = () => container.get('codeEntityRepository');
+        const getEdgeRepo = () => container.get('knowledgeEdgeRepository');
+        const getKnowledgeRepo = () => container.get('knowledgeRepository');
+        ct.singleton('moduleDiscoverer', () => new ModuleDiscoverer(getEntityRepo(), getEdgeRepo(), getProjectRoot()));
+        ct.singleton('roleRefiner', () => new RoleRefiner(getBootstrapRepo(), getEntityRepo(), getEdgeRepo(), getProjectRoot()));
+        ct.singleton('couplingAnalyzer', () => new CouplingAnalyzer(getEdgeRepo(), getEntityRepo(), getProjectRoot()));
         ct.singleton('layerInferrer', () => new LayerInferrer());
-        ct.singleton('dimensionAnalyzer', () => new DimensionAnalyzer(getDb()));
+        ct.singleton('dimensionAnalyzer', () => new DimensionAnalyzer(getBootstrapRepo(), getEntityRepo(), getKnowledgeRepo(), getProjectRoot()));
         ct.singleton('panoramaAggregator', (c) => {
             const sc = c;
             const roleRefiner = sc.get('roleRefiner');
@@ -43,7 +43,10 @@ export const PanoramaModule = {
                 roleRefiner,
                 couplingAnalyzer,
                 layerInferrer,
-                db: getDb(),
+                bootstrapRepo: getBootstrapRepo(),
+                entityRepo: getEntityRepo(),
+                edgeRepo: getEdgeRepo(),
+                knowledgeRepo: getKnowledgeRepo(),
                 projectRoot: getProjectRoot(),
                 dimensionAnalyzer,
             });
@@ -56,6 +59,8 @@ export const PanoramaModule = {
             return new PanoramaScanner({
                 projectRoot: getProjectRoot(),
                 container: container,
+                entityRepo: getEntityRepo(),
+                edgeRepo: getEdgeRepo(),
                 logger,
             });
         });
@@ -66,7 +71,8 @@ export const PanoramaModule = {
             const moduleDiscoverer = sc.get('moduleDiscoverer');
             return new PanoramaService({
                 aggregator,
-                db: getDb(),
+                edgeRepo: getEdgeRepo(),
+                knowledgeRepo: getKnowledgeRepo(),
                 projectRoot: getProjectRoot(),
                 scanner,
                 moduleDiscoverer,

package/dist/lib/injection/modules/VectorModule.js

@@ -39,6 +39,9 @@ export function register(c) {
                 : null,
             autoSyncOnCrud: config.autoSyncOnCrud !== false,
             syncDebounceMs: config.syncDebounceMs || 2000,
+            drizzle: ct.services.database
+                ? ct.get('database').getDrizzle?.()
+                : undefined,
         });
     }, { aiDependent: true });
 }

package/dist/lib/repository/audit/AuditRepository.d.ts

@@ -0,0 +1,107 @@
+/**
+ * AuditRepository — 审计日志的仓储实现
+ *
+ * 从 AuditStore 提取的数据操作，
+ * 使用 Drizzle 类型安全 API 操作 audit_logs 表。
+ */
+import { auditLogs } from '../../infrastructure/database/drizzle/schema.js';
+import { RepositoryBase } from '../base/RepositoryBase.js';
+export interface AuditLogEntity {
+    id: string;
+    timestamp: number;
+    actor: string;
+    actorContext: Record<string, unknown>;
+    action: string;
+    resource: string | null;
+    operationData: Record<string, unknown>;
+    result: string;
+    errorMessage: string | null;
+    duration: number | null;
+}
+export interface AuditLogInsert {
+    id: string;
+    timestamp: number;
+    actor: string;
+    actorContext?: string;
+    action: string;
+    resource?: string;
+    operationData?: string;
+    result: string;
+    errorMessage?: string | null;
+    duration?: number | null;
+}
+export interface AuditQueryFilters {
+    actor?: string;
+    action?: string;
+    result?: string;
+    startDate?: number;
+    endDate?: number;
+    limit?: number;
+}
+export interface AuditStats {
+    timeRange: string;
+    total: number;
+    success: number;
+    failure: number;
+    successRate: string;
+    avgDuration: string;
+    byActor: Array<{
+        actor: string;
+        count: number;
+    }>;
+    byAction: Array<{
+        action: string;
+        count: number;
+    }>;
+}
+export declare class AuditRepositoryImpl extends RepositoryBase<typeof auditLogs, AuditLogEntity> {
+    #private;
+    constructor(drizzle: ConstructorParameters<typeof RepositoryBase<typeof auditLogs, AuditLogEntity>>[0]);
+    findById(id: string): Promise<AuditLogEntity | null>;
+    create(data: AuditLogInsert): Promise<AuditLogEntity>;
+    delete(id: string): Promise<boolean>;
+    /** 动态多条件查询 */
+    query(filters?: AuditQueryFilters): Promise<AuditLogEntity[]>;
+    /** 根据请求 ID 查询 */
+    findByRequestId(requestId: string): Promise<AuditLogEntity | null>;
+    /** 根据角色查询 */
+    findByActor(actor: string, limit?: number): Promise<AuditLogEntity[]>;
+    /** 根据操作查询 */
+    findByAction(action: string, limit?: number): Promise<AuditLogEntity[]>;
+    /** 根据结果查询 */
+    findByResult(result: string, limit?: number): Promise<AuditLogEntity[]>;
+    /** 获取统计数据 */
+    getStats(timeRange?: string): Promise<AuditStats>;
+    /**
+     * 清理过期审计日志
+     * @param maxAgeDays 保留天数
+     */
+    cleanup(maxAgeDays?: number): Promise<{
+        deleted: number;
+    }>;
+    /**
+     * Guard 违规规则名 TOP-N (SkillAdvisor.#getGuardPatterns)
+     */
+    findTopGuardViolationRules(minCount: number, limit: number): Promise<Array<{
+        ruleName: string;
+        cnt: number;
+    }>>;
+    /**
+     * Guard 违规信号 (SignalCollector.#collectGuardSignals)
+     */
+    findGuardViolationSignals(limit: number): Promise<Array<{
+        ruleName: string;
+        cnt: number;
+        lastAt: number;
+    }>>;
+    /**
+     * 最近动作日志 (SignalCollector.#collectActionSignals)
+     */
+    findRecentActions(sinceTs: number, limit: number): Promise<Array<{
+        actor: string;
+        action: string;
+        resource: string | null;
+        result: string;
+        timestamp: number;
+    }>>;
+}