autosnippet 3.2.15 → 3.2.17

package/dist/lib/service/skills/SkillHooks.js

@@ -1,14 +1,15 @@
 /**
- * SkillHooks — Skill 生命周期钩子管理器
+ * SkillHooks — Skill 生命周期钩子管理器 (v2)
  *
  * 每个 Skill 目录可以包含一个 hooks.js 文件，导出生命周期回调。
- * SkillHooks 在启动时扫描并注册所有钩子，在特定事件发生时按序调用。
+ * SkillHooks 在启动时扫描并注册所有钩子，在特定事件发生时按模式调用。
  *
- * 支持的钩子:
- *   - onCandidateSubmit(candidate, ctx) → { block?: boolean, reason?: string }
- *   - onRecipeCreated(recipe, ctx) → void
- *   - onGuardCheck(violation, ctx) → violation (可修改)
- *   - onBootstrapComplete(stats, ctx) → void
+ * v2 升级:
+ *   - 扩展到 16+ 钩子，覆盖知识/Guard/Skill/搜索/推荐/Bootstrap/信号全生命周期
+ *   - 4 种执行模式: series / parallel / waterfall / bail
+ *   - Handler 支持 priority、timeout、name 元数据
+ *   - 完全向后兼容旧版 hooks.js (直接导出函数)
+ *   - 新格式支持: export default { hooks: { onXxx: { handler, priority, timeout } } }
  *
  * 加载顺序: 内置 skills/ → 项目级 AutoSnippet/skills/（同名覆盖）
  */
@@ -18,6 +19,45 @@ import { resolveProjectRoot } from '#shared/resolveProjectRoot.js';
 import { getProjectSkillsPath } from '../../infrastructure/config/Paths.js';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { SKILLS_DIR } from '../../shared/package-root.js';
+// ═══════════════════════════════════════════════════════
+//  Hook Registry — 声明所有支持的钩子及其执行模式
+// ═══════════════════════════════════════════════════════
+const HOOK_REGISTRY = [
+    // ── 知识生命周期 ──
+    { name: 'onKnowledgeSubmit', mode: 'bail', description: '知识提交前拦截' },
+    { name: 'onKnowledgeCreated', mode: 'parallel', description: '知识创建后通知' },
+    { name: 'onKnowledgeUpdated', mode: 'parallel', description: '知识更新后通知' },
+    { name: 'onKnowledgeExpired', mode: 'parallel', description: '知识过期/废弃后通知' },
+    // ── Guard ──
+    { name: 'onGuardCheck', mode: 'waterfall', description: 'Guard 检查，可修改违规结果' },
+    { name: 'onGuardViolation', mode: 'parallel', description: 'Guard 违规后通知' },
+    // ── Skill 生命周期 ──
+    { name: 'onSkillLoad', mode: 'series', description: 'Skill 被加载时' },
+    { name: 'onSkillCreated', mode: 'parallel', description: 'Skill 创建后' },
+    { name: 'onSkillExpired', mode: 'parallel', description: 'Skill 过期/删除后' },
+    // ── 搜索 ──
+    { name: 'onSearch', mode: 'waterfall', description: '搜索结果后处理（可修改排序）' },
+    { name: 'onSearchMiss', mode: 'parallel', description: '搜索无结果时' },
+    // ── 推荐 ──
+    { name: 'onRecommendation', mode: 'waterfall', description: '推荐结果后处理（可过滤/排序）' },
+    { name: 'onRecommendFeedback', mode: 'parallel', description: '推荐反馈事件' },
+    // ── Bootstrap ──
+    { name: 'onBootstrapStart', mode: 'series', description: '冷启动开始前' },
+    { name: 'onBootstrapComplete', mode: 'parallel', description: '冷启动完成后' },
+    // ── 信号 ──
+    { name: 'onSignalCollected', mode: 'parallel', description: '新信号收集完成' },
+    // ── 向后兼容 (旧名映射) ──
+    { name: 'onCandidateSubmit', mode: 'bail', description: '(compat) 同 onKnowledgeSubmit' },
+    { name: 'onRecipeCreated', mode: 'parallel', description: '(compat) Recipe 创建后通知' },
+];
+/** hookName → HookDefinition 快速查表 */
+const HOOK_DEF_MAP = new Map(HOOK_REGISTRY.map((d) => [d.name, d]));
+/** 所有合法 hook 名称集合 */
+const HOOK_NAMES = new Set(HOOK_REGISTRY.map((d) => d.name));
+/** 默认 handler 超时 (ms) */
+const DEFAULT_HANDLER_TIMEOUT = 10_000;
+/** 默认 handler 优先级 */
+const DEFAULT_HANDLER_PRIORITY = 100;
 /**
  * 获取项目级 Skills 目录（运行时动态解析）
  * 路径: {projectRoot}/AutoSnippet/skills/
@@ -26,56 +66,132 @@ function _getProjectSkillsDir(container) {
     const projectRoot = resolveProjectRoot(container);
     return getProjectSkillsPath(projectRoot);
 }
-const HOOK_NAMES = ['onCandidateSubmit', 'onRecipeCreated', 'onGuardCheck', 'onBootstrapComplete'];
+/** 带超时的 Promise 包装 */
+function withTimeout(promise, ms, label) {
+    if (ms <= 0) {
+        return promise;
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error(`Hook handler "${label}" timed out after ${ms}ms`));
+        }, ms);
+        promise.then((v) => {
+            clearTimeout(timer);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+    });
+}
+// ═══════════════════════════════════════════════════════
+//  SkillHooks 主类
+// ═══════════════════════════════════════════════════════
 export class SkillHooks {
     hooks;
     logger;
     constructor() {
         this.logger = Logger.getInstance();
-        /** @type {Map<string, Function[]>} hookName → [handler, ...] */
-        this.hooks = new Map(HOOK_NAMES.map((n) => [n, []]));
+        this.hooks = new Map([...HOOK_NAMES].map((n) => [n, []]));
     }
+    // ─── 公共 API ──────────────────────────────────────────
     /**
      * 扫描 skills 目录，加载所有 hooks.js
      * 项目级 hooks 覆盖同名内置 hooks
      */
     async load(container) {
-        const loaded = new Map(); // skillName → hooks module
+        const loaded = new Map();
         // 1. 内置 skills
         await this.#loadFromDir(SKILLS_DIR, loaded);
         // 2. 项目级 skills（覆盖同名）
         await this.#loadFromDir(_getProjectSkillsDir(container), loaded);
         // 3. 注册所有钩子
         for (const [skillName, mod] of loaded) {
-            for (const hookName of HOOK_NAMES) {
-                if (typeof mod[hookName] === 'function') {
-                    this.hooks.get(hookName).push(mod[hookName]);
-                    this.logger.debug(`SkillHook registered: ${skillName}.${hookName}`);
-                }
-            }
+            this.#registerModule(skillName, mod);
+        }
+        // 4. 按优先级排序所有 hook 列表
+        for (const handlers of this.hooks.values()) {
+            handlers.sort((a, b) => a.priority - b.priority);
         }
         const totalHooks = [...this.hooks.values()].reduce((s, a) => s + a.length, 0);
         if (totalHooks > 0) {
             this.logger.info(`SkillHooks: loaded ${totalHooks} hooks from ${loaded.size} skills`);
         }
     }
+    /** 手动注册 handler (用于代码级注册，非 hooks.js) */
+    tap(hookName, handler, options) {
+        if (!HOOK_NAMES.has(hookName)) {
+            this.logger.warn(`SkillHooks.tap: unknown hook "${hookName}", registering dynamically`);
+            this.hooks.set(hookName, []);
+        }
+        const registered = {
+            fn: handler,
+            name: options?.name ?? 'anonymous',
+            priority: options?.priority ?? DEFAULT_HANDLER_PRIORITY,
+            timeout: options?.timeout ?? DEFAULT_HANDLER_TIMEOUT,
+        };
+        const handlers = this.hooks.get(hookName);
+        handlers.push(registered);
+        // 保持优先级排序
+        handlers.sort((a, b) => a.priority - b.priority);
+    }
     /**
-     * 触发钩子 — 按注册顺序调用
+     * 触发钩子 — 根据 hook 定义的模式自动选择执行策略
      *
-     * @param {string} hookName
-     * @param  {...any} args
-     * @returns {Promise<any>} 最后一个返回值（用于 blocking hooks 如 onCandidateSubmit）
+     * 向后兼容: 旧版 run() 签名不变，行为维持一致。
+     * - bail 模式: 首个返回 { block: true } 的 handler 立即终止
+     * - waterfall 模式: 前一个 handler 的返回值传给下一个
+     * - parallel 模式: 所有 handler 并行执行 (fire-and-forget)
+     * - series 模式: 按优先级顺序串行执行，忽略返回值
      */
     async run(hookName, ...args) {
         const handlers = this.hooks.get(hookName);
         if (!handlers || handlers.length === 0) {
             return undefined;
         }
+        const def = HOOK_DEF_MAP.get(hookName);
+        const mode = def?.mode ?? 'bail'; // 未知 hook 默认 bail (兼容旧行为)
+        switch (mode) {
+            case 'bail':
+                return this.#runBail(hookName, handlers, args);
+            case 'waterfall':
+                return this.#runWaterfall(hookName, handlers, args);
+            case 'parallel':
+                return this.#runParallel(hookName, handlers, args);
+            case 'series':
+                return this.#runSeries(hookName, handlers, args);
+            default:
+                return this.#runBail(hookName, handlers, args);
+        }
+    }
+    /** 检查是否有任何钩子注册 */
+    has(hookName) {
+        const handlers = this.hooks.get(hookName);
+        return handlers !== undefined && handlers.length > 0;
+    }
+    /** 获取指定 hook 的 handler 数量 */
+    count(hookName) {
+        return this.hooks.get(hookName)?.length ?? 0;
+    }
+    /** 获取已注册的所有 hook 名称 */
+    getRegisteredHooks() {
+        return [...this.hooks.entries()]
+            .filter(([, handlers]) => handlers.length > 0)
+            .map(([name]) => name);
+    }
+    /** 获取 Hook Registry 信息 (用于 Dashboard / 调试) */
+    static getHookRegistry() {
+        return HOOK_REGISTRY;
+    }
+    // ─── 执行模式实现 ─────────────────────────────────────
+    /** Bail 模式: 串行执行，首个返回 truthy/{block:true} 的 handler 终止链 */
+    async #runBail(hookName, handlers, args) {
         let result;
-        for (const handler of handlers) {
+        for (const h of handlers) {
             try {
-                result = await handler(...args);
-                // 如果是 blocking hook 且返回 block=true，立即中断
+                const promise = Promise.resolve(h.fn(...args));
+                result = await withTimeout(promise, h.timeout, h.name);
+                // block 短路
                 if (result &&
                     typeof result === 'object' &&
                     'block' in result &&
@@ -84,21 +200,116 @@ export class SkillHooks {
                 }
             }
             catch (err) {
-                this.logger.warn(`SkillHook error in ${hookName}`, {
+                this.logger.warn(`SkillHook error in ${hookName} (handler: ${h.name})`, {
                     error: err instanceof Error ? err.message : String(err),
                 });
             }
         }
         return result;
     }
+    /** Waterfall 模式: 串行传值，前一个返回值替换 args[0] */
+    async #runWaterfall(hookName, handlers, args) {
+        let current = args[0];
+        const rest = args.slice(1);
+        for (const h of handlers) {
+            try {
+                const promise = Promise.resolve(h.fn(current, ...rest));
+                const result = await withTimeout(promise, h.timeout, h.name);
+                // 只有返回了有效值才替换
+                if (result !== undefined && result !== null) {
+                    current = result;
+                }
+            }
+            catch (err) {
+                this.logger.warn(`SkillHook waterfall error in ${hookName} (handler: ${h.name})`, {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                // waterfall 模式下出错继续传递当前值
+            }
+        }
+        return current;
+    }
+    /** Parallel 模式: 所有 handler 并行执行 (fire-and-forget) */
+    async #runParallel(hookName, handlers, args) {
+        const results = await Promise.allSettled(handlers.map((h) => {
+            const promise = Promise.resolve(h.fn(...args));
+            return withTimeout(promise, h.timeout, h.name);
+        }));
+        // 记录失败但不阻塞
+        for (let i = 0; i < results.length; i++) {
+            const r = results[i];
+            if (r.status === 'rejected') {
+                this.logger.warn(`SkillHook parallel error in ${hookName} (handler: ${handlers[i].name})`, {
+                    error: r.reason instanceof Error ? r.reason.message : String(r.reason),
+                });
+            }
+        }
+        return undefined;
+    }
+    /** Series 模式: 按优先级顺序串行执行，忽略返回值 */
+    async #runSeries(hookName, handlers, args) {
+        for (const h of handlers) {
+            try {
+                const promise = Promise.resolve(h.fn(...args));
+                await withTimeout(promise, h.timeout, h.name);
+            }
+            catch (err) {
+                this.logger.warn(`SkillHook series error in ${hookName} (handler: ${h.name})`, {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        return undefined;
+    }
+    // ─── 模块注册 ─────────────────────────────────────────
     /**
-     * 检查是否有任何钩子注册
+     * 注册一个 skill 模块的钩子 — 支持新旧两种格式
+     *
+     * 旧格式 (v1):
+     *   export function onGuardCheck(violation, ctx) { ... }
+     *
+     * 新格式 (v2):
+     *   export default { hooks: { onGuardCheck: { handler, priority, timeout } } }
      */
-    has(hookName) {
-        const handlers = this.hooks.get(hookName);
-        return handlers && handlers.length > 0;
+    #registerModule(skillName, mod) {
+        // 尝试新格式: mod.hooks 是一个对象
+        const hooksObj = mod.hooks;
+        if (hooksObj && typeof hooksObj === 'object') {
+            for (const [hookName, config] of Object.entries(hooksObj)) {
+                if (!this.hooks.has(hookName)) {
+                    this.logger.warn(`SkillHooks: ${skillName} exports unknown hook "${hookName}", skipping`);
+                    continue;
+                }
+                if (typeof config === 'function') {
+                    // 新格式但直接是函数: { hooks: { onXxx: fn } }
+                    this.#addHandler(hookName, config, skillName);
+                }
+                else if (config && typeof config === 'object' && 'handler' in config) {
+                    // 新格式含元数据: { hooks: { onXxx: { handler, priority, timeout } } }
+                    const cfg = config;
+                    this.#addHandler(hookName, cfg.handler, skillName, cfg.priority, cfg.timeout);
+                }
+            }
+            return;
+        }
+        // 旧格式: module 顶层直接导出函数
+        for (const hookName of HOOK_NAMES) {
+            if (typeof mod[hookName] === 'function') {
+                this.#addHandler(hookName, mod[hookName], skillName);
+            }
+        }
+    }
+    #addHandler(hookName, fn, skillName, priority, timeout) {
+        const handler = {
+            fn,
+            name: `${skillName}.${hookName}`,
+            priority: priority ?? DEFAULT_HANDLER_PRIORITY,
+            timeout: timeout ?? DEFAULT_HANDLER_TIMEOUT,
+        };
+        this.hooks.get(hookName).push(handler);
+        this.logger.debug(`SkillHook registered: ${handler.name} (priority=${handler.priority})`);
     }
-    // ─── Internal ──────────────────────────────────────────
+    // ─── 目录扫描 ─────────────────────────────────────────
     async #loadFromDir(dir, loaded) {
         let dirs;
         try {
@@ -128,4 +339,3 @@ export class SkillHooks {
     }
 }
 export default SkillHooks;
-//# sourceMappingURL=SkillHooks.js.map

package/dist/lib/service/skills/types.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Skill 推荐系统 — 统一类型定义
+ *
+ * 覆盖: SignalProvider / RecommendationPipeline / FeedbackStore / SkillHooks
+ */
+/** Hook 执行模式 — 受 Webpack Tapable 启发，简化为 4 种核心语义 */
+export type HookMode = 
+/** 串行执行，所有 handler 按优先级顺序执行，忽略返回值 */
+'series'
+/** 并行执行，所有 handler Promise.allSettled (fire-and-forget) */
+ | 'parallel'
+/** 串行传值，前一个 handler 的返回值作为下一个的第一个参数 */
+ | 'waterfall'
+/** 串行短路，首个返回 truthy 值（含 {block:true}）的 handler 终止链 */
+ | 'bail';
+/** Hook 定义 */
+export interface HookDefinition {
+    name: string;
+    mode: HookMode;
+    description: string;
+}
+/** Handler 注册选项 */
+export interface HookHandlerOptions {
+    /** handler 名称 (用于日志和调试) */
+    name: string;
+    /** 执行优先级 (越小越先，默认 100) */
+    priority?: number;
+    /** 超时 (ms)，超时自动跳过，默认 10000 */
+    timeout?: number;
+}
+/** 已注册的 Handler 内部表示 */
+export interface RegisteredHandler {
+    fn: (...args: unknown[]) => Promise<unknown> | unknown;
+    name: string;
+    priority: number;
+    timeout: number;
+}
+/** 标准化信号对象 */
+export interface Signal {
+    id: string;
+    provider: string;
+    type: string;
+    timestamp: Date;
+    data: Record<string, unknown>;
+    /** 信号强度 0-1 */
+    strength: number;
+    /** 可选的去重 key */
+    dedupeKey?: string;
+}
+/** 信号收集上下文 */
+export interface SignalContext {
+    projectRoot: string;
+    database?: unknown;
+    container?: unknown;
+}
+/** 统一信号提供者接口 */
+export interface SignalProvider {
+    /** 提供者唯一名称 */
+    readonly name: string;
+    /** 信号类别 */
+    readonly category: 'behavior' | 'quality' | 'context' | 'external';
+    /** 优先级 (越小越先执行) */
+    readonly priority: number;
+    /**
+     * 收集信号 — 增量模式
+     * @param since 上次收集的时间戳 (null = 首次)
+     * @param context 全局上下文
+     * @returns 标准化信号对象数组
+     */
+    collect(since: Date | null, context: SignalContext): Promise<Signal[]>;
+    /** 信号提供者是否可用 */
+    isAvailable(context: SignalContext): boolean;
+}
+/** 推荐候选 */
+export interface RecommendationCandidate {
+    /** 推荐的 Skill 名称 */
+    name: string;
+    /** 一句话描述 */
+    description: string;
+    /** 推荐理由 */
+    rationale: string;
+    /** 推荐来源策略 */
+    source: string;
+    /** 优先级 */
+    priority: 'high' | 'medium' | 'low';
+    /** 原始信号数据 */
+    signals: Record<string, unknown>;
+    /** 推荐内容草稿 (可选) */
+    body?: string;
+}
+/** 带分数的推荐结果 */
+export interface ScoredRecommendation extends RecommendationCandidate {
+    /** 综合得分 0-1 */
+    score: number;
+    /** 各信号分项得分 */
+    signalScores?: Record<string, number>;
+    /** 唯一推荐 ID (用于反馈追踪) */
+    recommendationId: string;
+    /** 推荐生成时间 */
+    generatedAt: string;
+}
+/** 推荐管线上下文 */
+export interface RecommendationContext {
+    projectRoot: string;
+    database?: unknown;
+    container?: unknown;
+    agentFactory?: unknown;
+    /** 已有的项目级 Skill 名称集合 (用于去重) */
+    existingSkills?: Set<string>;
+    /** 用户偏好 (来自 FeedbackStore) */
+    userPreference?: UserPreference;
+    /** AI Provider 是否可用 */
+    aiAvailable?: boolean;
+}
+/** 召回策略接口 */
+export interface RecallStrategy {
+    readonly name: string;
+    /** 召回方法类型 */
+    readonly type: 'rule' | 'ai' | 'vector' | 'popularity';
+    /** 召回候选列表 */
+    recall(context: RecommendationContext): Promise<RecommendationCandidate[]>;
+    /** 策略是否可用 (例如 AI 策略需要 aiProvider) */
+    isAvailable(context: RecommendationContext): boolean;
+}
+/** 推荐反馈动作 */
+export type FeedbackAction = 
+/** 用户采纳推荐并创建了 Skill */
+'adopted'
+/** 用户主动关闭/忽略推荐 */
+ | 'dismissed'
+/** 推荐过期未处理 */
+ | 'expired'
+/** 用户查看了推荐详情 */
+ | 'viewed'
+/** 用户采纳但修改了内容 */
+ | 'modified';
+/** 推荐反馈记录 */
+export interface RecommendationFeedback {
+    recommendationId: string;
+    action: FeedbackAction;
+    timestamp: string;
+    /** 推荐来源策略 */
+    source?: string;
+    /** 推荐类别 */
+    category?: string;
+    /** 用户反馈原因 */
+    reason?: string;
+}
+/** 用户偏好 (从反馈历史中推导) */
+export interface UserPreference {
+    preferredCategories: string[];
+    avoidedCategories: string[];
+    preferredSources: string[];
+    /** 总体采纳率 */
+    adoptionRate: number;
+}
+/** 推荐效果指标 */
+export interface RecommendationMetricsSnapshot {
+    /** 总推荐数 */
+    totalRecommendations: number;
+    /** 总展示数 */
+    totalViewed: number;
+    /** 总采纳数 */
+    totalAdopted: number;
+    /** 总忽略数 */
+    totalDismissed: number;
+    /** 总过期数 */
+    totalExpired: number;
+    /** 采纳率 */
+    adoptionRate: number;
+    /** 查看率 */
+    viewRate: number;
+    /** 按来源分组的采纳率 */
+    adoptionRateBySource: Record<string, number>;
+    /** 统计时间范围 */
+    since: string;
+}

package/dist/lib/service/skills/types.js

@@ -0,0 +1,6 @@
+/**
+ * Skill 推荐系统 — 统一类型定义
+ *
+ * 覆盖: SignalProvider / RecommendationPipeline / FeedbackStore / SkillHooks
+ */
+export {};

package/dist/lib/service/snippet/SnippetFactory.d.ts

@@ -46,56 +46,38 @@ interface ListFilters {
 export declare class SnippetFactory {
     #private;
     _recipeRepo: KnowledgeRepository | null;
-    /**
-     * @param {object} [knowledgeRepository] - KnowledgeRepositoryImpl（可选）
-     */
+    /** @param [knowledgeRepository] KnowledgeRepositoryImpl（可选） */
     constructor(knowledgeRepository?: KnowledgeRepository | null);
-    /**
-     * 注册一个 IDE codec
-     * @param {import('./codecs/SnippetCodec.js').SnippetCodec} codec
-     */
+    /** 注册一个 IDE codec */
     registerCodec(codec: SnippetCodec): void;
     /**
      * 获取已注册的 codec
-     * @param {string} target - 'xcode' | 'vscode'
-     * @returns {import('./codecs/SnippetCodec.js').SnippetCodec|undefined}
+     * @param target 'xcode' | 'vscode'
      */
     getCodec(target: string): SnippetCodec | undefined;
-    /**
-     * 获取所有已注册 codec 的 ID 列表
-     * @returns {string[]}
-     */
+    /** 获取所有已注册 codec 的 ID 列表 */
     getRegisteredTargets(): string[];
-    /**
-     * 运行时注入 knowledgeRepository（用于延迟绑定场景）
-     */
+    /** 运行时注入 knowledgeRepository（用于延迟绑定场景） */
     setKnowledgeRepository(repo: KnowledgeRepository): void;
     /**
      * 从 Recipe 列表实时生成 Snippet 列表
-     * @param {object} [filters] - { language, category, keyword }
-     * @param {object} [pagination]
-     * @returns {Promise<Array>}
+     * @param [filters] { language, category, keyword }
      */
     listSnippets(filters?: ListFilters, pagination?: {
         page: number;
         pageSize: number;
     }): Promise<SnippetSpec[]>;
-    /**
-     * 从单个 Recipe ID 实时生成 Snippet
-     */
+    /** 从单个 Recipe ID 实时生成 Snippet */
     getSnippet(recipeId: string): Promise<SnippetSpec | null>;
     /**
      * 使用指定 codec 从 spec 生成 IDE 格式内容
-     * @param {object} spec - SnippetSpec
-     * @param {string} [target='xcode'] - codec ID
-     * @returns {string}
+     * @param spec SnippetSpec
+     * @param [target='xcode'] codec ID
      */
     generate(spec: SnippetSpec, target?: string): string;
     /**
      * 批量生成 (委托 codec)
-     * @param {Array} recipes
-     * @param {string} [target='xcode']
-     * @returns {Array<{ filename: string, content: string, spec: object }> | { filename: string, content: string, specs: object[] }}
+     * @returns > | { filename: string, content: string, specs: object[] }}
      */
     generateBatch(recipes: RecipeLike[], target?: string): {
         filename: string;
@@ -111,10 +93,9 @@ export declare class SnippetFactory {
     };
     /**
      * 从 Recipe/Candidate 生成 IDE 无关的 snippet spec
-     * @param {object} recipe - { id, title, trigger, code, description, language }
-     * @returns {object} - SnippetSpec
+     * @param recipe { id, title, trigger, code, description, language }
+     * @returns SnippetSpec
      */
     fromRecipe(recipe: RecipeLike): SnippetSpec;
 }
 export {};
-//# sourceMappingURL=SnippetFactory.d.ts.map