autosnippet 3.2.16 → 3.2.18

package/dist/lib/infrastructure/vector/ScalarQuantizer.d.ts

@@ -13,53 +13,33 @@
  */
 export declare class ScalarQuantizer {
     #private;
-    /**
-     * @param {number} dimension 向量维度
-     */
+    /** @param dimension 向量维度 */
     constructor(dimension: number);
     get dimension(): number;
     get trained(): boolean;
     /**
      * 训练量化器 — 从一批向量中统计 per-dimension min/max
-     * @param {Array<Float32Array|number[]>} vectors 训练集 (建议 ≥ 100 条)
+     * @param vectors 训练集 (建议 ≥ 100 条)
      */
     train(vectors: Array<Float32Array | number[]>): void;
-    /**
-     * 量化单个向量
-     * @param {Float32Array|number[]} vector
-     * @returns {Uint8Array}
-     */
+    /** 量化单个向量 */
     encode(vector: Float32Array | number[]): Uint8Array<ArrayBuffer>;
-    /**
-     * 批量量化
-     * @param {Array<Float32Array|number[]>} vectors
-     * @returns {Uint8Array[]}
-     */
+    /** 批量量化 */
     encodeBatch(vectors: Array<Float32Array | number[]>): Uint8Array<ArrayBuffer>[];
-    /**
-     * 反量化 (用于精排 re-rank)
-     * @param {Uint8Array} quantized
-     * @returns {Float32Array}
-     */
+    /** 反量化 (用于精排 re-rank) */
     decode(quantized: Uint8Array): Float32Array<ArrayBuffer>;
     /**
      * 量化空间内的距离计算 (避免反量化, 整数运算)
      * 使用 L2 on quantized space 近似余弦距离
      *
-     * @param {Uint8Array} a
-     * @param {Uint8Array} b
-     * @returns {number} 距离值 (越小越相似)
+     * @returns 距离值 (越小越相似)
      */
     distance(a: Uint8Array, b: Uint8Array): number;
     /**
      * 混合距离: 量化粗排 + 原始精排
      * 用于搜索时: 先用 SQ8 快速过滤, 再用 Float32 精确计算
      *
-     * @param {Uint8Array} quantizedA
-     * @param {Float32Array|number[]} originalA
-     * @param {Uint8Array} quantizedB
-     * @param {Float32Array|number[]} originalB
-     * @returns {{ coarse: number, fine: number }}
+     * @returns }
      */
     hybridDistance(quantizedA: Uint8Array, originalA: Float32Array | number[], quantizedB: Uint8Array, originalB: Float32Array | number[]): {
         coarse: number;
@@ -67,7 +47,7 @@ export declare class ScalarQuantizer {
     };
     /**
      * 序列化量化器参数
-     * @returns {{ dimension: number, mins: number[], maxs: number[] }}
+     * @returns }
      */
     serialize(): {
         dimension: number;
@@ -77,7 +57,6 @@ export declare class ScalarQuantizer {
     /**
      * 从序列化数据恢复量化器
      * @param {{ dimension: number, mins: number[], maxs: number[] }} data
-     * @returns {ScalarQuantizer}
      */
     static deserialize(data: {
         dimension: number;
@@ -85,4 +64,3 @@ export declare class ScalarQuantizer {
         maxs: number[];
     }): ScalarQuantizer;
 }
-//# sourceMappingURL=ScalarQuantizer.d.ts.map

package/dist/lib/infrastructure/vector/ScalarQuantizer.js

@@ -20,9 +20,7 @@ export class ScalarQuantizer {
     /** @type {Float32Array} 每维范围 (max - min), 预计算避免重复减法 */
     #ranges;
     #trained = false;
-    /**
-     * @param {number} dimension 向量维度
-     */
+    /** @param dimension 向量维度 */
     constructor(dimension) {
         this.#dimension = dimension;
         this.#mins = new Float32Array(dimension);
@@ -37,7 +35,7 @@ export class ScalarQuantizer {
     }
     /**
      * 训练量化器 — 从一批向量中统计 per-dimension min/max
-     * @param {Array<Float32Array|number[]>} vectors 训练集 (建议 ≥ 100 条)
+     * @param vectors 训练集 (建议 ≥ 100 条)
      */
     train(vectors) {
         if (!vectors || vectors.length === 0) {
@@ -68,11 +66,7 @@ export class ScalarQuantizer {
         this.#ranges = ranges;
         this.#trained = true;
     }
-    /**
-     * 量化单个向量
-     * @param {Float32Array|number[]} vector
-     * @returns {Uint8Array}
-     */
+    /** 量化单个向量 */
     encode(vector) {
         if (!this.#trained) {
             throw new Error('ScalarQuantizer not trained. Call train() first.');
@@ -89,19 +83,11 @@ export class ScalarQuantizer {
         }
         return result;
     }
-    /**
-     * 批量量化
-     * @param {Array<Float32Array|number[]>} vectors
-     * @returns {Uint8Array[]}
-     */
+    /** 批量量化 */
     encodeBatch(vectors) {
         return vectors.map((v) => this.encode(v));
     }
-    /**
-     * 反量化 (用于精排 re-rank)
-     * @param {Uint8Array} quantized
-     * @returns {Float32Array}
-     */
+    /** 反量化 (用于精排 re-rank) */
     decode(quantized) {
         if (!this.#trained) {
             throw new Error('ScalarQuantizer not trained.');
@@ -119,9 +105,7 @@ export class ScalarQuantizer {
      * 量化空间内的距离计算 (避免反量化, 整数运算)
      * 使用 L2 on quantized space 近似余弦距离
      *
-     * @param {Uint8Array} a
-     * @param {Uint8Array} b
-     * @returns {number} 距离值 (越小越相似)
+     * @returns 距离值 (越小越相似)
      */
     distance(a, b) {
         const dim = this.#dimension;
@@ -137,11 +121,7 @@ export class ScalarQuantizer {
      * 混合距离: 量化粗排 + 原始精排
      * 用于搜索时: 先用 SQ8 快速过滤, 再用 Float32 精确计算
      *
-     * @param {Uint8Array} quantizedA
-     * @param {Float32Array|number[]} originalA
-     * @param {Uint8Array} quantizedB
-     * @param {Float32Array|number[]} originalB
-     * @returns {{ coarse: number, fine: number }}
+     * @returns }
      */
     hybridDistance(quantizedA, originalA, quantizedB, originalB) {
         return {
@@ -149,12 +129,7 @@ export class ScalarQuantizer {
             fine: ScalarQuantizer.#cosineDistanceFloat(originalA, originalB),
         };
     }
-    /**
-     * 余弦距离 (Float32 精确计算)
-     * @param {Float32Array|number[]} a
-     * @param {Float32Array|number[]} b
-     * @returns {number}
-     */
+    /** 余弦距离 (Float32 精确计算) */
     static #cosineDistanceFloat(a, b) {
         if (!a || !b || a.length === 0) {
             return 1;
@@ -171,7 +146,7 @@ export class ScalarQuantizer {
     }
     /**
      * 序列化量化器参数
-     * @returns {{ dimension: number, mins: number[], maxs: number[] }}
+     * @returns }
      */
     serialize() {
         return {
@@ -183,7 +158,6 @@ export class ScalarQuantizer {
     /**
      * 从序列化数据恢复量化器
      * @param {{ dimension: number, mins: number[], maxs: number[] }} data
-     * @returns {ScalarQuantizer}
      */
     static deserialize(data) {
         const q = new ScalarQuantizer(data.dimension);
@@ -199,4 +173,3 @@ export class ScalarQuantizer {
         return q;
     }
 }
-//# sourceMappingURL=ScalarQuantizer.js.map

package/dist/lib/infrastructure/vector/VectorMigration.d.ts

@@ -12,9 +12,8 @@ export declare class VectorMigration {
     /**
      * 检测并执行自动迁移
      *
-     * @param {string} indexDir - 索引目录路径
-     * @param {import('./HnswVectorAdapter.js').HnswVectorAdapter} adapter - HNSW 适配器实例
-     * @returns {Promise<'new'|'migrated'|'binary'>}
+     * @param indexDir 索引目录路径
+     * @param adapter HNSW 适配器实例
      */
     static migrate(indexDir: string, adapter: {
         batchUpsert: (items: Array<{
@@ -24,11 +23,6 @@ export declare class VectorMigration {
             metadata: Record<string, unknown>;
         }>) => Promise<void>;
     }): Promise<"binary" | "new" | "migrated">;
-    /**
-     * 检查是否需要迁移
-     * @param {string} indexDir
-     * @returns {boolean}
-     */
+    /** 检查是否需要迁移 */
     static needsMigration(indexDir: string): boolean;
 }
-//# sourceMappingURL=VectorMigration.d.ts.map

package/dist/lib/infrastructure/vector/VectorMigration.js

@@ -14,9 +14,8 @@ export class VectorMigration {
     /**
      * 检测并执行自动迁移
      *
-     * @param {string} indexDir - 索引目录路径
-     * @param {import('./HnswVectorAdapter.js').HnswVectorAdapter} adapter - HNSW 适配器实例
-     * @returns {Promise<'new'|'migrated'|'binary'>}
+     * @param indexDir 索引目录路径
+     * @param adapter HNSW 适配器实例
      */
     static async migrate(indexDir, adapter) {
         const jsonPath = join(indexDir, 'vector_index.json');
@@ -73,15 +72,10 @@ export class VectorMigration {
         // 场景 1: 全新安装
         return 'new';
     }
-    /**
-     * 检查是否需要迁移
-     * @param {string} indexDir
-     * @returns {boolean}
-     */
+    /** 检查是否需要迁移 */
     static needsMigration(indexDir) {
         const jsonPath = join(indexDir, 'vector_index.json');
         const hnswPath = join(indexDir, 'vector_index.asvec');
         return existsSync(jsonPath) && !existsSync(hnswPath);
     }
 }
-//# sourceMappingURL=VectorMigration.js.map

package/dist/lib/infrastructure/vector/VectorStore.d.ts

@@ -3,10 +3,7 @@
  * 定义向量存储的标准接口，支持 JSON/Milvus 等后端
  */
 export declare class VectorStore {
-    /**
-     * 初始化存储
-     * @returns {Promise<void>}
-     */
+    /** 初始化存储 */
     init(): Promise<void>;
     /**
      * 插入或更新文档
@@ -18,32 +15,21 @@ export declare class VectorStore {
         vector: number[];
         metadata: Record<string, unknown>;
     }): Promise<void>;
-    /**
-     * 批量 upsert
-     * @param {Array} items
-     */
+    /** 批量 upsert */
     batchUpsert(items: Array<{
         id: string;
         content: string;
         vector: number[];
         metadata: Record<string, unknown>;
     }>): Promise<void>;
-    /**
-     * 删除文档
-     * @param {string} id
-     */
+    /** 删除文档 */
     remove(id: string): Promise<void>;
-    /**
-     * 按 ID 获取
-     * @param {string} id
-     * @returns {Promise<object|null>}
-     */
+    /** 按 ID 获取 */
     getById(id: string): Promise<Record<string, unknown> | null>;
     /**
      * 向量相似度搜索
-     * @param {number[]} queryVector
-     * @param {object} options - { topK, filter, minScore }
-     * @returns {Promise<Array<{ item: object, score: number }>>}
+     * @param options { topK, filter, minScore }
+     * @returns >>}
      */
     searchVector(queryVector: number[], options?: Record<string, unknown>): Promise<Array<{
         item: Record<string, unknown>;
@@ -51,22 +37,16 @@ export declare class VectorStore {
     }>>;
     /**
      * 按过滤条件搜索
-     * @param {object} filter - { type, category, language, tags, ... }
-     * @returns {Promise<Array>}
+     * @param filter { type, category, language, tags, ... }
      */
     searchByFilter(filter: Record<string, unknown>): Promise<Record<string, unknown>[]>;
-    /**
-     * 列出所有 ID
-     * @returns {Promise<string[]>}
-     */
+    /** 列出所有 ID */
     listIds(): Promise<string[]>;
-    /**
-     * 清空存储
-     */
+    /** 清空存储 */
     clear(): Promise<void>;
     /**
      * 获取统计信息
-     * @returns {Promise<{ count: number, indexSize: number }>}
+     * @returns >}
      */
     getStats(): Promise<{
         count: number;
@@ -78,4 +58,3 @@ export declare class VectorStore {
      */
     destroy(): void;
 }
-//# sourceMappingURL=VectorStore.d.ts.map

package/dist/lib/infrastructure/vector/VectorStore.js

@@ -4,10 +4,7 @@
  */
 import { ioLimit } from '#shared/concurrency.js';
 export class VectorStore {
-    /**
-     * 初始化存储
-     * @returns {Promise<void>}
-     */
+    /** 初始化存储 */
     async init() {
         throw new Error('Not implemented: init()');
     }
@@ -18,62 +15,45 @@ export class VectorStore {
     async upsert(item) {
         throw new Error('Not implemented: upsert()');
     }
-    /**
-     * 批量 upsert
-     * @param {Array} items
-     */
+    /** 批量 upsert */
     async batchUpsert(items) {
         // p-limit 控制并发，避免批量 upsert 时 OOM 或 DB 锁竞争
         await Promise.all(items.map((item) => ioLimit(() => this.upsert(item))));
     }
-    /**
-     * 删除文档
-     * @param {string} id
-     */
+    /** 删除文档 */
     async remove(id) {
         throw new Error('Not implemented: remove()');
     }
-    /**
-     * 按 ID 获取
-     * @param {string} id
-     * @returns {Promise<object|null>}
-     */
+    /** 按 ID 获取 */
     async getById(id) {
         throw new Error('Not implemented: getById()');
     }
     /**
      * 向量相似度搜索
-     * @param {number[]} queryVector
-     * @param {object} options - { topK, filter, minScore }
-     * @returns {Promise<Array<{ item: object, score: number }>>}
+     * @param options { topK, filter, minScore }
+     * @returns >>}
      */
     async searchVector(queryVector, options = {}) {
         throw new Error('Not implemented: searchVector()');
     }
     /**
      * 按过滤条件搜索
-     * @param {object} filter - { type, category, language, tags, ... }
-     * @returns {Promise<Array>}
+     * @param filter { type, category, language, tags, ... }
      */
     async searchByFilter(filter) {
         throw new Error('Not implemented: searchByFilter()');
     }
-    /**
-     * 列出所有 ID
-     * @returns {Promise<string[]>}
-     */
+    /** 列出所有 ID */
     async listIds() {
         throw new Error('Not implemented: listIds()');
     }
-    /**
-     * 清空存储
-     */
+    /** 清空存储 */
     async clear() {
         throw new Error('Not implemented: clear()');
     }
     /**
      * 获取统计信息
-     * @returns {Promise<{ count: number, indexSize: number }>}
+     * @returns >}
      */
     async getStats() {
         throw new Error('Not implemented: getStats()');
@@ -86,4 +66,3 @@ export class VectorStore {
         // no-op by default
     }
 }
-//# sourceMappingURL=VectorStore.js.map

package/dist/lib/injection/ServiceContainer.d.ts

@@ -14,21 +14,19 @@ export declare class ServiceContainer {
     /**
      * 注册一个惰性单例服务 — 消除 `if (!this.singletons.xxx)` 样板代码
      *
-     * @param {string} name 服务名称
-     * @param {(container: ServiceContainer) => any} factory 工厂函数（首次 get 时执行）
+     * @param name 服务名称
+     * @param factory 工厂函数（首次 get 时执行）
      * @param {{ aiDependent?: boolean }} [options] 选项
      *   - aiDependent: 标记为 AI Provider 依赖项，热重载时自动清除缓存
      */
     singleton(name: string, factory: (container: ServiceContainer) => unknown, options?: {
         aiDependent?: boolean;
     }): void;
-    /**
-     * 静态单例获取（路由层使用）
-     */
+    /** 静态单例获取（路由层使用） */
     static getInstance(): ServiceContainer;
     /**
      * 初始化所有服务和仓储
-     * @param {object} bootstrapComponents - Bootstrap 初始化的组件（db, auditLogger, gateway 等）
+     * @param bootstrapComponents Bootstrap 初始化的组件（db, auditLogger, gateway 等）
      */
     initialize(bootstrapComponents?: Record<string, unknown>): Promise<void>;
     /**
@@ -39,19 +37,11 @@ export declare class ServiceContainer {
      *  2. 重新创建 _embedProvider（如果主 provider 不支持 embedding）
      *  3. 清除已缓存的依赖 AI 的 singleton（SearchEngine 等），
      *     下次 get() 时会用新 provider 重新创建
-     *
-     * @param {import('../external/ai/AiProvider.js').AiProvider} newProvider
      */
     reloadAiProvider(newProvider: Record<string, unknown> | null): void;
-    /**
-     * 获取当前默认 UI 语言偏好
-     * @returns {'zh'|'en'|null}
-     */
+    /** 获取当前默认 UI 语言偏好 */
     getLang(): {} | null;
-    /**
-     * 设置默认 UI 语言偏好（影响 Agent 回复语言）
-     * @param {'zh'|'en'|null} lang
-     */
+    /** 设置默认 UI 语言偏好（影响 Agent 回复语言） */
     setLang(lang: 'zh' | 'en' | null): void;
     /**
      * 构建 ToolRegistry.execute() 所需的上下文对象。
@@ -59,13 +49,11 @@ export declare class ServiceContainer {
      * 工具执行上下文构建
      * 迁移后: 所有直接调用 ToolRegistry 的站点都使用此方法
      *
-     * @param {Object} [extras] 合并到上下文的额外字段
-     * @returns {Object} 工具执行上下文
+     * @param [extras] 合并到上下文的额外字段
+     * @returns 工具执行上下文
      */
     buildToolContext(extras?: Record<string, unknown>): Record<string, unknown>;
-    /**
-     * 注册服务或工厂函数
-     */
+    /** 注册服务或工厂函数 */
     register(name: string, factory: () => unknown): void;
     /**
      * 获取服务（类型安全版本）
@@ -80,30 +68,20 @@ export declare class ServiceContainer {
      */
     get<K extends keyof ServiceMap>(name: K): ServiceMap[K];
     get(name: string): unknown;
-    /**
-     * 清除所有单例（用于测试）
-     */
+    /** 清除所有单例（用于测试） */
     reset(): void;
-    /**
-     * 获取所有已注册的服务名
-     */
+    /** 获取所有已注册的服务名 */
     getServiceNames(): string[];
     /**
      * 构建 ProjectGraph (v3.0 AST 结构图)
      * 优先从磁盘缓存加载，支持 per-file hash 增量更新
-     * @param {string} projectRoot 项目根目录
-     * @param {object} [options] 传递给 ProjectGraph.build() 的选项
-     * @returns {Promise<import('../core/ast/ProjectGraph.js').default|null>}
+     * @param projectRoot 项目根目录
+     * @param [options] 传递给 ProjectGraph.build() 的选项
      */
     buildProjectGraph(projectRoot: string, options?: Record<string, unknown>): Promise<{} | null>;
 }
-/**
- * 获取全局服务容器实例
- */
+/** 获取全局服务容器实例 */
 export declare function getServiceContainer(): ServiceContainer;
-/**
- * 重置全局服务容器（主要用于测试）
- */
+/** 重置全局服务容器（主要用于测试） */
 export declare function resetServiceContainer(): void;
 export default ServiceContainer;
-//# sourceMappingURL=ServiceContainer.d.ts.map

package/dist/lib/injection/ServiceContainer.js

@@ -34,8 +34,8 @@ export class ServiceContainer {
     /**
      * 注册一个惰性单例服务 — 消除 `if (!this.singletons.xxx)` 样板代码
      *
-     * @param {string} name 服务名称
-     * @param {(container: ServiceContainer) => any} factory 工厂函数（首次 get 时执行）
+     * @param name 服务名称
+     * @param factory 工厂函数（首次 get 时执行）
      * @param {{ aiDependent?: boolean }} [options] 选项
      *   - aiDependent: 标记为 AI Provider 依赖项，热重载时自动清除缓存
      */
@@ -53,15 +53,13 @@ export class ServiceContainer {
             return this.singletons[name];
         });
     }
-    /**
-     * 静态单例获取（路由层使用）
-     */
+    /** 静态单例获取（路由层使用） */
     static getInstance() {
         return getServiceContainer();
     }
     /**
      * 初始化所有服务和仓储
-     * @param {object} bootstrapComponents - Bootstrap 初始化的组件（db, auditLogger, gateway 等）
+     * @param bootstrapComponents Bootstrap 初始化的组件（db, auditLogger, gateway 等）
      */
     async initialize(bootstrapComponents = {}) {
         try {
@@ -143,8 +141,6 @@ export class ServiceContainer {
      *  2. 重新创建 _embedProvider（如果主 provider 不支持 embedding）
      *  3. 清除已缓存的依赖 AI 的 singleton（SearchEngine 等），
      *     下次 get() 时会用新 provider 重新创建
-     *
-     * @param {import('../external/ai/AiProvider.js').AiProvider} newProvider
      */
     reloadAiProvider(newProvider) {
         const old = this.singletons.aiProvider;
@@ -172,17 +168,11 @@ export class ServiceContainer {
         });
     }
     // ─── 容器级语言偏好 ─────
-    /**
-     * 获取当前默认 UI 语言偏好
-     * @returns {'zh'|'en'|null}
-     */
+    /** 获取当前默认 UI 语言偏好 */
     getLang() {
         return this.singletons._lang || null;
     }
-    /**
-     * 设置默认 UI 语言偏好（影响 Agent 回复语言）
-     * @param {'zh'|'en'|null} lang
-     */
+    /** 设置默认 UI 语言偏好（影响 Agent 回复语言） */
     setLang(lang) {
         this.singletons._lang = lang || null;
     }
@@ -193,8 +183,8 @@ export class ServiceContainer {
      * 工具执行上下文构建
      * 迁移后: 所有直接调用 ToolRegistry 的站点都使用此方法
      *
-     * @param {Object} [extras] 合并到上下文的额外字段
-     * @returns {Object} 工具执行上下文
+     * @param [extras] 合并到上下文的额外字段
+     * @returns 工具执行上下文
      */
     buildToolContext(extras = {}) {
         return {
@@ -208,9 +198,7 @@ export class ServiceContainer {
             ...extras,
         };
     }
-    /**
-     * 注册服务或工厂函数
-     */
+    /** 注册服务或工厂函数 */
     register(name, factory) {
         if (this.services[name] && process.env.NODE_ENV !== 'production') {
             this.logger.warn(`[ServiceContainer] 服务 "${name}" 被重复注册，前一个工厂将被覆盖`);
@@ -223,24 +211,19 @@ export class ServiceContainer {
         }
         return this.services[name]();
     }
-    /**
-     * 清除所有单例（用于测试）
-     */
+    /** 清除所有单例（用于测试） */
     reset() {
         this.singletons = {};
     }
-    /**
-     * 获取所有已注册的服务名
-     */
+    /** 获取所有已注册的服务名 */
     getServiceNames() {
         return Object.keys(this.services);
     }
     /**
      * 构建 ProjectGraph (v3.0 AST 结构图)
      * 优先从磁盘缓存加载，支持 per-file hash 增量更新
-     * @param {string} projectRoot 项目根目录
-     * @param {object} [options] 传递给 ProjectGraph.build() 的选项
-     * @returns {Promise<import('../core/ast/ProjectGraph.js').default|null>}
+     * @param projectRoot 项目根目录
+     * @param [options] 传递给 ProjectGraph.build() 的选项
      */
     async buildProjectGraph(projectRoot, options = {}) {
         if (this.singletons.projectGraph) {
@@ -302,12 +285,7 @@ export class ServiceContainer {
             return null;
         }
     }
-    /**
-     * 收集项目源码文件路径（用于 hash 计算）
-     * @param {string} projectRoot
-     * @param {object} options
-     * @returns {string[]}
-     */
+    /** 收集项目源码文件路径（用于 hash 计算） */
     #collectSourceFilePaths(projectRoot, options = {}) {
         const DEFAULTS_EXT = { '.m': true, '.h': true, '.swift': true };
         const extSet = new Set(options.extensions || Object.keys(DEFAULTS_EXT));
@@ -367,22 +345,17 @@ export class ServiceContainer {
     }
 }
 let containerInstance = null;
-/**
- * 获取全局服务容器实例
- */
+/** 获取全局服务容器实例 */
 export function getServiceContainer() {
     if (!containerInstance) {
         containerInstance = new ServiceContainer();
     }
     return containerInstance;
 }
-/**
- * 重置全局服务容器（主要用于测试）
- */
+/** 重置全局服务容器（主要用于测试） */
 export function resetServiceContainer() {
     if (containerInstance) {
         containerInstance.reset();
     }
 }
 export default ServiceContainer;
-//# sourceMappingURL=ServiceContainer.js.map