autosnippet 3.3.7 → 3.3.8

package/dist/lib/repository/base/RepositoryBase.d.ts

@@ -0,0 +1,46 @@
+/**
+ * RepositoryBase — Drizzle-first 仓储基类
+ *
+ * 与旧 BaseRepository 的区别：
+ * - 构造器接收 DrizzleDB 而非 raw Database
+ * - 子类应使用 Drizzle 类型安全 API 实现 CRUD
+ * - 保留 rawQuery() 作为复杂查询逃生舱
+ * - 无 _assertSafeColumn() —— Drizzle 自带列类型约束
+ */
+import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { Logger as WinstonLogger } from 'winston';
+import type { DrizzleDB } from '../../infrastructure/database/drizzle/index.js';
+/** Drizzle 事务类型 */
+export type DrizzleTx = Parameters<Parameters<DrizzleDB['transaction']>[0]>[0];
+export interface PaginationOptions {
+    page?: number;
+    pageSize?: number;
+}
+export interface PaginatedResult<T> {
+    data: T[];
+    pagination: {
+        page: number;
+        pageSize: number;
+        total: number;
+        pages: number;
+    };
+}
+/**
+ * 新基类：以 Drizzle typed API 为主，raw SQL 为逃生舱。
+ *
+ * @typeParam TTable  Drizzle 表定义（如 typeof knowledgeEdges）
+ * @typeParam TEntity 领域实体类型
+ */
+export declare abstract class RepositoryBase<TTable extends SQLiteTable, TEntity> {
+    protected readonly drizzle: DrizzleDB;
+    protected readonly table: TTable;
+    protected readonly logger: WinstonLogger;
+    constructor(drizzle: DrizzleDB, table: TTable);
+    /**
+     * Drizzle 事务包装 — 所有 DB 变更意图应在事务内执行
+     */
+    protected transaction<R>(fn: (tx: DrizzleTx) => R): R;
+    abstract findById(id: string | number): Promise<TEntity | null>;
+    abstract create(data: unknown): Promise<TEntity>;
+    abstract delete(id: string | number): Promise<boolean>;
+}

package/dist/lib/repository/base/RepositoryBase.js

@@ -0,0 +1,32 @@
+/**
+ * RepositoryBase — Drizzle-first 仓储基类
+ *
+ * 与旧 BaseRepository 的区别：
+ * - 构造器接收 DrizzleDB 而非 raw Database
+ * - 子类应使用 Drizzle 类型安全 API 实现 CRUD
+ * - 保留 rawQuery() 作为复杂查询逃生舱
+ * - 无 _assertSafeColumn() —— Drizzle 自带列类型约束
+ */
+import Logger from '../../infrastructure/logging/Logger.js';
+/**
+ * 新基类：以 Drizzle typed API 为主，raw SQL 为逃生舱。
+ *
+ * @typeParam TTable  Drizzle 表定义（如 typeof knowledgeEdges）
+ * @typeParam TEntity 领域实体类型
+ */
+export class RepositoryBase {
+    drizzle;
+    table;
+    logger;
+    constructor(drizzle, table) {
+        this.drizzle = drizzle;
+        this.table = table;
+        this.logger = Logger.getInstance();
+    }
+    /**
+     * Drizzle 事务包装 — 所有 DB 变更意图应在事务内执行
+     */
+    transaction(fn) {
+        return this.drizzle.transaction(fn);
+    }
+}

package/dist/lib/repository/bootstrap/BootstrapRepository.d.ts

@@ -0,0 +1,94 @@
+/**
+ * BootstrapRepository — Bootstrap 快照的仓储实现
+ *
+ * 从 BootstrapSnapshot 提取的数据操作，
+ * 使用 Drizzle 类型安全 API 操作 bootstrap_snapshots + bootstrap_dim_files 表。
+ */
+import { bootstrapSnapshots } from '../../infrastructure/database/drizzle/schema.js';
+import { RepositoryBase } from '../base/RepositoryBase.js';
+export interface BootstrapSnapshotEntity {
+    id: string;
+    sessionId: string | null;
+    projectRoot: string;
+    createdAt: string;
+    durationMs: number;
+    fileCount: number;
+    dimensionCount: number;
+    candidateCount: number;
+    primaryLang: string | null;
+    fileHashes: Record<string, string>;
+    dimensionMeta: Record<string, DimensionStatMeta>;
+    episodicData: Record<string, unknown> | null;
+    isIncremental: boolean;
+    parentId: string | null;
+    changedFiles: string[];
+    affectedDims: string[];
+    status: string;
+}
+export interface DimensionStatMeta {
+    candidateCount: number;
+    analysisChars: number;
+    referencedFiles: number;
+    durationMs: number;
+}
+export interface BootstrapSnapshotInsert {
+    id: string;
+    sessionId?: string | null;
+    projectRoot: string;
+    createdAt: string;
+    durationMs?: number;
+    fileCount?: number;
+    dimensionCount?: number;
+    candidateCount?: number;
+    primaryLang?: string | null;
+    fileHashes: Record<string, string>;
+    dimensionMeta: Record<string, DimensionStatMeta>;
+    episodicData?: unknown | null;
+    isIncremental?: boolean;
+    parentId?: string | null;
+    changedFiles?: string[];
+    affectedDims?: string[];
+    status?: string;
+}
+export interface DimFileInsert {
+    snapshotId: string;
+    dimId: string;
+    filePath: string;
+    role?: string;
+}
+export interface DimFileEntry {
+    dimId: string;
+    filePath: string;
+}
+export declare class BootstrapRepositoryImpl extends RepositoryBase<typeof bootstrapSnapshots, BootstrapSnapshotEntity> {
+    #private;
+    /** 默认快照保留数量 */
+    static readonly MAX_SNAPSHOTS = 5;
+    constructor(drizzle: ConstructorParameters<typeof RepositoryBase<typeof bootstrapSnapshots, BootstrapSnapshotEntity>>[0]);
+    findById(id: string): Promise<BootstrapSnapshotEntity | null>;
+    create(data: BootstrapSnapshotInsert): Promise<BootstrapSnapshotEntity>;
+    delete(id: string): Promise<boolean>;
+    /** 获取项目最新完成的快照 */
+    getLatest(projectRoot: string): Promise<BootstrapSnapshotEntity | null>;
+    /** 获取项目的快照列表 (按时间降序) */
+    listByProject(projectRoot: string, limit?: number): Promise<BootstrapSnapshotEntity[]>;
+    /** 批量插入维度-文件关联 (INSERT OR IGNORE) */
+    saveDimFiles(entries: DimFileInsert[]): Promise<number>;
+    /** 获取快照的维度-文件关联 */
+    getDimFiles(snapshotId: string): Promise<DimFileEntry[]>;
+    /** 获取快照中每个维度引用的文件集合 */
+    getDimFileMap(snapshotId: string): Promise<Record<string, Set<string>>>;
+    /** 保留项目最新 N 个快照，删除旧的 */
+    enforceCapacity(projectRoot: string, maxSnapshots?: number): Promise<number>;
+    /** 清除项目的所有快照 */
+    clearProject(projectRoot: string): Promise<number>;
+    /**
+     * 事务保存快照 + 维度-文件关联 + 容量控制
+     * 替代 BootstrapSnapshot.save() 中的事务逻辑
+     */
+    saveWithDimFiles(snapshot: BootstrapSnapshotInsert, dimFiles: DimFileInsert[]): Promise<BootstrapSnapshotEntity>;
+    /** 获取项目最新的主语言 (Panorama 域用于维度/角色检测) */
+    getLatestPrimaryLang(projectRoot: string): Promise<string | null>;
+    /** 获取快照总数 */
+    getSnapshotCount(projectRoot?: string): Promise<number>;
+}

package/dist/lib/repository/bootstrap/BootstrapRepository.js

@@ -0,0 +1,246 @@
+/**
+ * BootstrapRepository — Bootstrap 快照的仓储实现
+ *
+ * 从 BootstrapSnapshot 提取的数据操作，
+ * 使用 Drizzle 类型安全 API 操作 bootstrap_snapshots + bootstrap_dim_files 表。
+ */
+import { and, count, desc, eq, sql } from 'drizzle-orm';
+import { bootstrapDimFiles, bootstrapSnapshots, } from '../../infrastructure/database/drizzle/schema.js';
+import { RepositoryBase } from '../base/RepositoryBase.js';
+/* ═══ Repository 实现 ═══ */
+export class BootstrapRepositoryImpl extends RepositoryBase {
+    /** 默认快照保留数量 */
+    static MAX_SNAPSHOTS = 5;
+    constructor(drizzle) {
+        super(drizzle, bootstrapSnapshots);
+    }
+    /* ─── CRUD ─── */
+    async findById(id) {
+        const rows = this.drizzle.select().from(this.table).where(eq(this.table.id, id)).limit(1).all();
+        return rows.length > 0 ? this.#mapRow(rows[0]) : null;
+    }
+    async create(data) {
+        this.drizzle
+            .insert(this.table)
+            .values({
+            id: data.id,
+            sessionId: data.sessionId ?? null,
+            projectRoot: data.projectRoot,
+            createdAt: data.createdAt,
+            durationMs: data.durationMs ?? 0,
+            fileCount: data.fileCount ?? 0,
+            dimensionCount: data.dimensionCount ?? 0,
+            candidateCount: data.candidateCount ?? 0,
+            primaryLang: data.primaryLang ?? null,
+            fileHashes: JSON.stringify(data.fileHashes),
+            dimensionMeta: JSON.stringify(data.dimensionMeta),
+            episodicData: data.episodicData ? JSON.stringify(data.episodicData) : null,
+            isIncremental: data.isIncremental ? 1 : 0,
+            parentId: data.parentId ?? null,
+            changedFiles: JSON.stringify(data.changedFiles ?? []),
+            affectedDims: JSON.stringify(data.affectedDims ?? []),
+            status: data.status ?? 'complete',
+        })
+            .run();
+        return (await this.findById(data.id));
+    }
+    async delete(id) {
+        const result = this.drizzle.delete(this.table).where(eq(this.table.id, id)).run();
+        return result.changes > 0;
+    }
+    /* ─── 快照查询 ─── */
+    /** 获取项目最新完成的快照 */
+    async getLatest(projectRoot) {
+        const rows = this.drizzle
+            .select()
+            .from(this.table)
+            .where(and(eq(this.table.projectRoot, projectRoot), eq(this.table.status, 'complete')))
+            .orderBy(desc(this.table.createdAt))
+            .limit(1)
+            .all();
+        return rows.length > 0 ? this.#mapRow(rows[0]) : null;
+    }
+    /** 获取项目的快照列表 (按时间降序) */
+    async listByProject(projectRoot, limit = 10) {
+        const rows = this.drizzle
+            .select()
+            .from(this.table)
+            .where(eq(this.table.projectRoot, projectRoot))
+            .orderBy(desc(this.table.createdAt))
+            .limit(limit)
+            .all();
+        return rows.map((r) => this.#mapRow(r));
+    }
+    /* ─── 维度-文件关联 ─── */
+    /** 批量插入维度-文件关联 (INSERT OR IGNORE) */
+    async saveDimFiles(entries) {
+        if (entries.length === 0) {
+            return 0;
+        }
+        let inserted = 0;
+        this.transaction((tx) => {
+            for (const entry of entries) {
+                tx.insert(bootstrapDimFiles)
+                    .values({
+                    snapshotId: entry.snapshotId,
+                    dimId: entry.dimId,
+                    filePath: entry.filePath,
+                    role: entry.role ?? 'referenced',
+                })
+                    .onConflictDoNothing()
+                    .run();
+                inserted++;
+            }
+        });
+        return inserted;
+    }
+    /** 获取快照的维度-文件关联 */
+    async getDimFiles(snapshotId) {
+        const rows = this.drizzle
+            .select({
+            dimId: bootstrapDimFiles.dimId,
+            filePath: bootstrapDimFiles.filePath,
+        })
+            .from(bootstrapDimFiles)
+            .where(eq(bootstrapDimFiles.snapshotId, snapshotId))
+            .all();
+        return rows;
+    }
+    /** 获取快照中每个维度引用的文件集合 */
+    async getDimFileMap(snapshotId) {
+        const entries = await this.getDimFiles(snapshotId);
+        const map = {};
+        for (const row of entries) {
+            if (!map[row.dimId]) {
+                map[row.dimId] = new Set();
+            }
+            map[row.dimId].add(row.filePath);
+        }
+        return map;
+    }
+    /* ─── 容量控制 ─── */
+    /** 保留项目最新 N 个快照，删除旧的 */
+    async enforceCapacity(projectRoot, maxSnapshots = BootstrapRepositoryImpl.MAX_SNAPSHOTS) {
+        const result = this.drizzle
+            .delete(this.table)
+            .where(and(eq(this.table.projectRoot, projectRoot), sql `${this.table.id} NOT IN (
+            SELECT ${this.table.id} FROM ${this.table}
+            WHERE ${this.table.projectRoot} = ${projectRoot}
+            ORDER BY ${this.table.createdAt} DESC
+            LIMIT ${maxSnapshots}
+          )`))
+            .run();
+        return result.changes;
+    }
+    /** 清除项目的所有快照 */
+    async clearProject(projectRoot) {
+        const snapshots = await this.listByProject(projectRoot, 9999);
+        let deleted = 0;
+        for (const snap of snapshots) {
+            if (await this.delete(snap.id)) {
+                deleted++;
+            }
+        }
+        return deleted;
+    }
+    /* ─── 事务保存 ─── */
+    /**
+     * 事务保存快照 + 维度-文件关联 + 容量控制
+     * 替代 BootstrapSnapshot.save() 中的事务逻辑
+     */
+    async saveWithDimFiles(snapshot, dimFiles) {
+        this.transaction((tx) => {
+            // 主记录
+            tx.insert(this.table)
+                .values({
+                id: snapshot.id,
+                sessionId: snapshot.sessionId ?? null,
+                projectRoot: snapshot.projectRoot,
+                createdAt: snapshot.createdAt,
+                durationMs: snapshot.durationMs ?? 0,
+                fileCount: snapshot.fileCount ?? 0,
+                dimensionCount: snapshot.dimensionCount ?? 0,
+                candidateCount: snapshot.candidateCount ?? 0,
+                primaryLang: snapshot.primaryLang ?? null,
+                fileHashes: JSON.stringify(snapshot.fileHashes),
+                dimensionMeta: JSON.stringify(snapshot.dimensionMeta),
+                episodicData: snapshot.episodicData ? JSON.stringify(snapshot.episodicData) : null,
+                isIncremental: snapshot.isIncremental ? 1 : 0,
+                parentId: snapshot.parentId ?? null,
+                changedFiles: JSON.stringify(snapshot.changedFiles ?? []),
+                affectedDims: JSON.stringify(snapshot.affectedDims ?? []),
+                status: snapshot.status ?? 'complete',
+            })
+                .run();
+            // 维度-文件关联
+            for (const df of dimFiles) {
+                tx.insert(bootstrapDimFiles)
+                    .values({
+                    snapshotId: df.snapshotId,
+                    dimId: df.dimId,
+                    filePath: df.filePath,
+                    role: df.role ?? 'referenced',
+                })
+                    .onConflictDoNothing()
+                    .run();
+            }
+            // 容量控制
+            tx.delete(this.table)
+                .where(and(eq(this.table.projectRoot, snapshot.projectRoot), sql `${this.table.id} NOT IN (
+              SELECT ${this.table.id} FROM ${this.table}
+              WHERE ${this.table.projectRoot} = ${snapshot.projectRoot}
+              ORDER BY ${this.table.createdAt} DESC
+              LIMIT ${BootstrapRepositoryImpl.MAX_SNAPSHOTS}
+            )`))
+                .run();
+        });
+        return (await this.findById(snapshot.id));
+    }
+    /** 获取项目最新的主语言 (Panorama 域用于维度/角色检测) */
+    async getLatestPrimaryLang(projectRoot) {
+        const rows = this.drizzle
+            .select({ primaryLang: this.table.primaryLang })
+            .from(this.table)
+            .where(eq(this.table.projectRoot, projectRoot))
+            .orderBy(desc(this.table.createdAt))
+            .limit(1)
+            .all();
+        return rows.length > 0 ? (rows[0].primaryLang ?? null) : null;
+    }
+    /** 获取快照总数 */
+    async getSnapshotCount(projectRoot) {
+        const condition = projectRoot ? eq(this.table.projectRoot, projectRoot) : undefined;
+        const [row] = this.drizzle.select({ cnt: count() }).from(this.table).where(condition).all();
+        return row?.cnt ?? 0;
+    }
+    /* ─── 内部辅助 ─── */
+    #mapRow(row) {
+        return {
+            id: row.id,
+            sessionId: row.sessionId ?? null,
+            projectRoot: row.projectRoot,
+            createdAt: row.createdAt,
+            durationMs: row.durationMs ?? 0,
+            fileCount: row.fileCount ?? 0,
+            dimensionCount: row.dimensionCount ?? 0,
+            candidateCount: row.candidateCount ?? 0,
+            primaryLang: row.primaryLang ?? null,
+            fileHashes: safeParseJSON(row.fileHashes, {}),
+            dimensionMeta: safeParseJSON(row.dimensionMeta, {}),
+            episodicData: safeParseJSON(row.episodicData, null),
+            isIncremental: !!row.isIncremental,
+            parentId: row.parentId ?? null,
+            changedFiles: safeParseJSON(row.changedFiles, []),
+            affectedDims: safeParseJSON(row.affectedDims, []),
+            status: row.status ?? 'complete',
+        };
+    }
+}
+function safeParseJSON(str, fallback) {
+    try {
+        return str ? JSON.parse(str) : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/lib/repository/code/CodeEntityRepository.d.ts

@@ -0,0 +1,91 @@
+/**
+ * CodeEntityRepository — AST 代码实体的仓储实现
+ *
+ * 从 CodeEntityGraph 和 PanoramaScanner 提取的数据操作，
+ * 使用 Drizzle 类型安全 API。
+ */
+import { codeEntities } from '../../infrastructure/database/drizzle/schema.js';
+import { RepositoryBase } from '../base/RepositoryBase.js';
+export interface CodeEntity {
+    id: number;
+    entityId: string;
+    entityType: string;
+    projectRoot: string;
+    name: string;
+    filePath: string | null;
+    lineNumber: number | null;
+    superclass: string | null;
+    protocols: string[];
+    metadata: Record<string, unknown>;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface CodeEntityInsert {
+    entityId: string;
+    entityType: string;
+    projectRoot: string;
+    name: string;
+    filePath?: string | null;
+    lineNumber?: number | null;
+    superclass?: string | null;
+    protocols?: string[];
+    metadata?: Record<string, unknown>;
+}
+export declare class CodeEntityRepositoryImpl extends RepositoryBase<typeof codeEntities, CodeEntity> {
+    #private;
+    constructor(drizzle: ConstructorParameters<typeof RepositoryBase<typeof codeEntities, CodeEntity>>[0]);
+    findById(id: number): Promise<CodeEntity | null>;
+    create(data: CodeEntityInsert): Promise<CodeEntity>;
+    delete(id: number): Promise<boolean>;
+    /** UPSERT — 按 (entityId, entityType, projectRoot) 唯一约束 */
+    upsert(entity: CodeEntityInsert): Promise<CodeEntity>;
+    /** 批量 UPSERT */
+    batchUpsert(entities: CodeEntityInsert[]): Promise<number>;
+    /** 按文件路径查询 */
+    findByFile(filePath: string, projectRoot: string): Promise<CodeEntity[]>;
+    /** 按实体类型列表 */
+    listByType(entityType: string, projectRoot: string, limit?: number): Promise<CodeEntity[]>;
+    /** 按名称搜索 */
+    searchByName(query: string, projectRoot: string, options?: {
+        entityType?: string;
+        limit?: number;
+    }): Promise<CodeEntity[]>;
+    /** 按 entityId + entityType + projectRoot 精确查找 */
+    findByEntityId(entityId: string, entityType: string, projectRoot: string): Promise<CodeEntity | null>;
+    /** 删除指定项目的所有实体 */
+    clearProject(projectRoot: string): Promise<number>;
+    /** 删除指定文件的实体（用于增量更新调用图） */
+    deleteByFile(filePath: string, projectRoot: string): Promise<number>;
+    /** 获取实体总数 */
+    getEntityCount(projectRoot?: string): Promise<number>;
+    /** 按类型统计实体数 */
+    countByType(projectRoot: string): Promise<Record<string, number>>;
+    /** 按文件路径和实体类型删除 */
+    deleteByFileAndType(filePath: string, entityType: string, projectRoot: string): Promise<number>;
+    /** 按 entityId + projectRoot 查找（不限 entityType） */
+    findByEntityIdOnly(entityId: string, projectRoot: string): Promise<CodeEntity | null>;
+    /** 查询非 module 实体的 (entityId, filePath) 去重列表 */
+    findDistinctEntityIdsWithFilePath(projectRoot: string): Promise<Array<{
+        entityId: string;
+        filePath: string;
+    }>>;
+    /** 查询本地模块 (排除 external/host nodeType) */
+    findLocalModules(projectRoot: string): Promise<Array<{
+        entityId: string;
+        name: string;
+    }>>;
+    /** 查询指定 nodeType 的模块实体 */
+    findModulesByNodeTypes(projectRoot: string, nodeTypes: string[]): Promise<CodeEntity[]>;
+    /** 统计指定 nodeType 的模块数量 */
+    countModulesByNodeType(projectRoot: string, nodeType: string): Promise<number>;
+    /** 按 projectRoot + filePaths 批量查询实体 */
+    findByProjectAndFilePaths(projectRoot: string, filePaths: string[]): Promise<CodeEntity[]>;
+    /** 查询非 module 实体的去重文件路径列表 */
+    findDistinctFilePaths(projectRoot: string, limit?: number): Promise<string[]>;
+    /** 批量 INSERT OR IGNORE (不更新已存在的行) */
+    batchInsertIgnore(entities: CodeEntityInsert[]): Promise<number>;
+    /**
+     * 符号名是否存在 (ReverseGuard.#symbolExists)
+     */
+    existsByName(name: string): boolean;
+}