autosnippet 3.2.21 → 3.3.2

package/dist/lib/service/task/TaskKnowledgeBridge.js

@@ -1,298 +0,0 @@
-import { slimSearchResult } from '#service/search/SearchTypes.js';
-import { ioLimit } from '#shared/concurrency.js';
-import Logger from '../../infrastructure/logging/Logger.js';
-// ─── Constants ──────────────────────────────────────────
-/**
- * 搜索结果相关性阈值 — 低于此分数的结果不注入
- *
- * 真实分数分布 (BiliDemo, auto 模式 RRF+Ranking):
- *   min=0.434  P10=0.453  P25=0.460  median=0.479  P75=0.495  P90=0.505  max=0.534
- *   所有结果集中在 [0.43, 0.54]，0.15 无法过滤任何噪声。
- *
- * 阈值设定依据:
- *   0.44 — 过滤掉最边缘的低质量尾部结果（约过滤 P5 以下）
- */
-const RELEVANCE_THRESHOLD = 0.44;
-/** 缓存 TTL (ms) — 5 分钟 */
-const CACHE_TTL_MS = 300_000;
-/** 技术术语提取正则 */
-const TECH_TERM_PATTERNS = [
-    // CamelCase 类名 — 含常见 iOS/Android/Web 后缀
-    /\b[A-Z][a-zA-Z]+(?:Controller|ViewController|Service|Manager|Handler|View|Model|Request|Response|Provider|Repository|Factory|Builder|Delegate|Protocol|Router|Coordinator|Cell|Layout|Adapter|Module|Plugin|Monitor|Loader|Store|Cache|Config|Helper|Util|Extension|Category)\b/g,
-    // BD / UI / NS 前缀类名 (常见 iOS 项目)
-    /\b(?:BD|UI|NS|CG|CA|MK|AV|WK|SK|CL)[A-Z][a-zA-Z]{2,}\b/g,
-    // 反引号包裹的代码引用
-    /`([^`]+)`/g,
-    // 文件名引用 (xxx.swift / xxx.ts / xxx.json 等)
-    /\b[\w.-]+\.(?:swift|ts|tsx|js|jsx|py|java|kt|go|rs|rb|cpp|h|m|mm|json|yaml|yml|xml|gradle|plist|xib|storyboard)\b/g,
-];
-/**
- * TaskKnowledgeBridge — 任务 ↔ 知识桥接服务
- *
- * AutoSnippet 独有能力：返回「带知识上下文的任务」，而非裸任务。
- *
- * 桥接策略（v2 — 用户输入感知 + Multi-Query + 上下文透传 + 缓存）：
- *   1. 任务标题/描述 + 用户输入(userQuery) → Multi-Query 搜索知识库
- *   2. 传递 language / intent 上下文信号 → SearchEngine ContextBoost 生效
- *   3. 关联的 Guard 规则 → 优先嵌入任务上下文
- *   4. 任务级缓存 → 避免重复搜索
- */
-export class TaskKnowledgeBridge {
-    _search;
-    logger;
-    /** 任务级知识缓存 (taskId → CacheEntry) */
-    _cache = new Map();
-    constructor(searchEngine) {
-        this._search = searchEngine;
-        this.logger = Logger.getInstance();
-    }
-    /**
-     * 为就绪任务附加知识上下文
-     * 并行搜索，不阻塞主流程
-     *
-     * @param tasks  需要注入知识的任务列表
-     * @param options 上下文选项（userQuery / activeFile / language）
-     */
-    async enrichWithKnowledge(tasks, options) {
-        if (!tasks || tasks.length === 0) {
-            return tasks;
-        }
-        if (!this._search) {
-            return tasks;
-        }
-        const results = await Promise.allSettled(tasks.map((task) => ioLimit(() => this._buildContext(task, options))));
-        return tasks.map((task, i) => {
-            if (results[i].status === 'fulfilled' && results[i].value) {
-                task.knowledgeContext = results[i].value;
-            }
-            return task;
-        });
-    }
-    /**
-     * 独立搜索 — 仅基于 userQuery 搜索知识（不依赖任何 Task）
-     *
-     * 场景: prime() 时没有 ready tasks 但有用户输入，直接搜索知识库。
-     *
-     * @param userQuery 用户输入的原始文本
-     * @param options   可选的 language
-     */
-    async searchForQuery(userQuery, options) {
-        if (!this._search || !userQuery?.trim()) {
-            return null;
-        }
-        try {
-            const searchResult = await this._search.search(userQuery.trim(), {
-                mode: 'auto',
-                limit: 8,
-                rank: true,
-                context: {
-                    language: options?.language,
-                    intent: 'user-query-knowledge',
-                },
-            });
-            const allResults = (searchResult?.items || searchResult?.results || []).filter((r) => this._aboveThreshold(r));
-            if (allResults.length === 0) {
-                return null;
-            }
-            const knowledge = allResults.filter((r) => r.kind !== 'rule').slice(0, 5);
-            const guardRules = allResults.filter((r) => r.kind === 'rule').slice(0, 3);
-            return {
-                relatedKnowledge: knowledge.map((k) => this._projectItem(k)),
-                guardRules: guardRules.map((r) => this._projectItem(r)),
-                searchQuery: userQuery.trim(),
-            };
-        }
-        catch (err) {
-            this.logger.debug('TaskKnowledgeBridge.searchForQuery error', {
-                error: err.message,
-            });
-            return null;
-        }
-    }
-    // ═══ 私有方法 ═══════════════════════════════════════
-    /**
-     * 为单个任务构建知识上下文（v2 — multi-query + 上下文 + 缓存）
-     */
-    async _buildContext(task, options) {
-        const taskQuery = `${task.title} ${task.description}`.trim();
-        if (!taskQuery && !options?.userQuery) {
-            return null;
-        }
-        // ── P6: 缓存检查 ──
-        const contentKey = this._contentKey(taskQuery, options?.userQuery);
-        if (task.id) {
-            const cached = this._cache.get(task.id);
-            if (cached &&
-                cached.contentKey === contentKey &&
-                Date.now() - cached.timestamp < CACHE_TTL_MS) {
-                return cached.context;
-            }
-        }
-        try {
-            // ── P2: Multi-Query 策略 ──
-            const queries = this._buildSearchQueries(task, options?.userQuery);
-            const allResults = await this._multiQuerySearch(queries, {
-                language: options?.language,
-            });
-            // ── P4: 相关性阈值过滤 ──
-            const filtered = allResults.filter((r) => this._aboveThreshold(r));
-            // ── P4: 分类 & 增强投影 ──
-            const knowledge = filtered.filter((r) => r.kind !== 'rule').slice(0, 5);
-            const guardRules = filtered.filter((r) => r.kind === 'rule').slice(0, 3);
-            const context = {
-                relatedKnowledge: knowledge.map((k) => this._projectItem(k)),
-                guardRules: guardRules.map((r) => this._projectItem(r)),
-                searchQuery: queries.join(' | '),
-            };
-            // ── P6: 写入缓存 ──
-            if (task.id) {
-                this._cache.set(task.id, { context, contentKey, timestamp: Date.now() });
-                // 限制缓存大小 — 超出 100 条时淘汰最旧的
-                if (this._cache.size > 100) {
-                    const firstKey = this._cache.keys().next().value;
-                    if (firstKey !== undefined) {
-                        this._cache.delete(firstKey);
-                    }
-                }
-            }
-            return context;
-        }
-        catch (err) {
-            this.logger.debug('TaskKnowledgeBridge._buildContext error', {
-                taskId: task.id,
-                error: err.message,
-            });
-            return null;
-        }
-    }
-    /**
-     * P2: 构建多条互补搜索查询
-     *
-     * 策略:
-     *   Q1 (精确): 任务标题 — 通常最精练
-     *   Q2 (语义): 用户输入 — 包含更丰富的自然语义
-     *   Q3 (关键词): 从描述/用户输入提取技术术语
-     *
-     */
-    _buildSearchQueries(task, userQuery) {
-        const queries = [];
-        // Q1: 任务标题（最精练）
-        const title = task.title?.trim();
-        if (title) {
-            queries.push(title);
-        }
-        // Q2: 用户原始输入（与标题不同才添加）
-        const uq = userQuery?.trim();
-        if (uq && uq !== title) {
-            queries.push(uq);
-        }
-        // Q3: 技术术语提取 — 从描述 + 用户输入中提取
-        const corpus = [task.description, userQuery].filter(Boolean).join(' ');
-        const techTerms = this._extractTechTerms(corpus);
-        if (techTerms.length > 0) {
-            const termQuery = techTerms.join(' ');
-            // 避免与已有查询重复
-            if (!queries.includes(termQuery)) {
-                queries.push(termQuery);
-            }
-        }
-        // 兜底: 若上述都为空，用 title + description
-        if (queries.length === 0) {
-            const fallback = `${task.title} ${task.description}`.trim();
-            if (fallback) {
-                queries.push(fallback);
-            }
-        }
-        return queries;
-    }
-    /**
-     * P2: 从文本中提取技术术语（类名、文件名、API 名等）
-     */
-    _extractTechTerms(text) {
-        if (!text) {
-            return [];
-        }
-        const terms = new Set();
-        for (const pattern of TECH_TERM_PATTERNS) {
-            // 重置 lastIndex（全局正则复用安全）
-            pattern.lastIndex = 0;
-            let match;
-            while ((match = pattern.exec(text)) !== null) {
-                // 优先取捕获组（反引号中的内容），否则取整个匹配
-                const term = (match[1] || match[0]).trim();
-                if (term.length >= 2) {
-                    terms.add(term);
-                }
-            }
-        }
-        return [...terms].slice(0, 8); // 最多 8 个术语
-    }
-    /**
-     * P2 + P3: Multi-Query 搜索 + 合并去重
-     *
-     * 对每个 query 执行搜索（并行），合并结果并按 score 去重保留最高分。
-     */
-    async _multiQuerySearch(queries, options) {
-        if (queries.length === 0) {
-            return [];
-        }
-        // 单 query 直接搜索（优化常见情况）
-        if (queries.length === 1) {
-            return this._singleSearch(queries[0], options);
-        }
-        // 多 query 并行搜索
-        const searchPromises = queries.map((q) => this._singleSearch(q, options).catch(() => []));
-        const resultSets = await Promise.all(searchPromises);
-        // 合并去重 — 按 id 保留最高 score
-        const merged = new Map();
-        for (const results of resultSets) {
-            for (const item of results) {
-                const existing = merged.get(item.id);
-                if (!existing || item.score > existing.score) {
-                    merged.set(item.id, item);
-                }
-            }
-        }
-        // 按 score 降序排序
-        return [...merged.values()].sort((a, b) => (b.score || 0) - (a.score || 0));
-    }
-    /**
-     * 执行单次搜索（含 P3 上下文透传）
-     */
-    async _singleSearch(query, options) {
-        const searchResult = await this._search.search(query, {
-            mode: 'auto',
-            limit: 8,
-            rank: true,
-            context: {
-                language: options.language,
-                intent: 'task-knowledge',
-            },
-        });
-        return (searchResult?.items || searchResult?.results || []).slice(0, 8);
-    }
-    /**
-     * P4: 相关性阈值判断
-     */
-    _aboveThreshold(item) {
-        const score = item.score || 0;
-        return score >= RELEVANCE_THRESHOLD;
-    }
-    /**
-     * P4: 增强投影 — 使用统一 slimSearchResult() 投影函数
-     */
-    _projectItem(item) {
-        return slimSearchResult(item);
-    }
-    /**
-     * P6: 缓存键 — 基于 taskQuery + userQuery 的内容指纹
-     */
-    _contentKey(taskQuery, userQuery) {
-        return `${taskQuery}||${userQuery || ''}`;
-    }
-    /** 清除全部缓存（测试 / 索引重建后使用） */
-    clearCache() {
-        this._cache.clear();
-    }
-}
-export default TaskKnowledgeBridge;

package/dist/lib/service/task/TaskReadyEngine.d.ts

@@ -1,84 +0,0 @@
-import { Task } from '../../domain/task/Task.js';
-/**
- * TaskReadyEngine — 就绪检测引擎
- *
- * 核心能力：通过递归 CTE 计算传递性阻塞，返回所有无阻塞依赖的就绪任务。
- *
- * 排序策略 (默认 hybrid):
- *   priority ASC → 高优先级优先
- *   created_at ASC → 同优先级先创建优先（防止 starvation）
- */
-export declare class TaskReadyEngine {
-    _blockedStmt: ReturnType<import('better-sqlite3').Database['prepare']>;
-    _db: import('better-sqlite3').Database;
-    _depTreeStmt: ReturnType<import('better-sqlite3').Database['prepare']>;
-    _readyStmt: ReturnType<import('better-sqlite3').Database['prepare']>;
-    /** @param db raw SQLite handle */
-    constructor(db: import('better-sqlite3').Database);
-    private _prepareStatements;
-    /**
-     * 获取就绪任务（核心方法）
-     *
-     * 就绪 = status='open' 且无未完成的阻塞型依赖（传递性检测）
-     */
-    getReadyWork(options?: {
-        limit?: number;
-    }): Task[];
-    /**
-     * 获取被阻塞的任务列表
-     * @returns 带 blocked_by 字段的任务列表
-     */
-    getBlockedWork(): {
-        blockedBy: string[];
-        knowledgeContext?: Record<string, unknown> | undefined;
-        id?: string | null | undefined;
-        parentId?: string | null | undefined;
-        title?: string | undefined;
-        description?: string | undefined;
-        design?: string | undefined;
-        acceptance?: string | undefined;
-        notes?: string | undefined;
-        status?: string | undefined;
-        priority?: number | undefined;
-        taskType?: string | undefined;
-        closeReason?: string | undefined;
-        assignee?: string | undefined;
-        createdBy?: string | undefined;
-        createdAt?: number | undefined;
-        updatedAt?: number | undefined;
-        closedAt?: number | null | undefined;
-        contentHash?: string | null | undefined;
-        failCount?: number | undefined;
-        lastFailReason?: string | undefined;
-        metadata?: Record<string, unknown> | undefined;
-    }[];
-    /**
-     * 获取依赖树
-     * @returns 带 depth 的任务列表
-     */
-    getDependencyTree(taskId: string): {
-        depth: unknown;
-        knowledgeContext?: Record<string, unknown> | undefined;
-        id?: string | null | undefined;
-        parentId?: string | null | undefined;
-        title?: string | undefined;
-        description?: string | undefined;
-        design?: string | undefined;
-        acceptance?: string | undefined;
-        notes?: string | undefined;
-        status?: string | undefined;
-        priority?: number | undefined;
-        taskType?: string | undefined;
-        closeReason?: string | undefined;
-        assignee?: string | undefined;
-        createdBy?: string | undefined;
-        createdAt?: number | undefined;
-        updatedAt?: number | undefined;
-        closedAt?: number | null | undefined;
-        contentHash?: string | null | undefined;
-        failCount?: number | undefined;
-        lastFailReason?: string | undefined;
-        metadata?: Record<string, unknown> | undefined;
-    }[];
-}
-export default TaskReadyEngine;

package/dist/lib/service/task/TaskReadyEngine.js

@@ -1,115 +0,0 @@
-import { Task } from '../../domain/task/Task.js';
-/**
- * TaskReadyEngine — 就绪检测引擎
- *
- * 核心能力：通过递归 CTE 计算传递性阻塞，返回所有无阻塞依赖的就绪任务。
- *
- * 排序策略 (默认 hybrid):
- *   priority ASC → 高优先级优先
- *   created_at ASC → 同优先级先创建优先（防止 starvation）
- */
-export class TaskReadyEngine {
-    _blockedStmt;
-    _db;
-    _depTreeStmt;
-    _readyStmt;
-    /** @param db raw SQLite handle */
-    constructor(db) {
-        this._db = db;
-        this._prepareStatements();
-    }
-    _prepareStatements() {
-        // ── 核心: 递归 CTE 计算传递性阻塞 ──
-        this._readyStmt = this._db.prepare(`
-      WITH RECURSIVE blocked_tasks(id, depth) AS (
-        -- Base case: 直接被阻塞的任务
-        SELECT td.task_id, 1
-        FROM task_dependencies td
-        JOIN tasks blocker ON td.depends_on_id = blocker.id
-        WHERE td.dep_type IN ('blocks', 'waits-for')
-          AND blocker.status != 'closed'
-
-        UNION
-
-        -- Recursive case: 传递性阻塞（深度保护 ≤ 50 层）
-        SELECT td.task_id, bt.depth + 1
-        FROM task_dependencies td
-        JOIN blocked_tasks bt ON td.depends_on_id = bt.id
-        WHERE td.dep_type IN ('blocks', 'waits-for')
-          AND bt.depth < 50
-      )
-      SELECT t.*
-      FROM tasks t
-      WHERE t.status = 'open'
-        AND t.id NOT IN (SELECT id FROM blocked_tasks)
-      ORDER BY t.priority ASC, t.created_at ASC
-      LIMIT ?
-    `);
-        // ── 查询被阻塞的任务 ──
-        this._blockedStmt = this._db.prepare(`
-      SELECT t.*, GROUP_CONCAT(td.depends_on_id) as blocked_by
-      FROM tasks t
-      JOIN task_dependencies td ON t.id = td.task_id
-      JOIN tasks blocker ON td.depends_on_id = blocker.id
-      WHERE t.status IN ('open', 'in_progress')
-        AND td.dep_type IN ('blocks', 'waits-for')
-        AND blocker.status != 'closed'
-      GROUP BY t.id
-      ORDER BY t.priority ASC
-    `);
-        // ── 依赖树查询 ──
-        this._depTreeStmt = this._db.prepare(`
-      WITH RECURSIVE dep_tree(id, depth, path) AS (
-        SELECT depends_on_id, 1, depends_on_id
-        FROM task_dependencies
-        WHERE task_id = ?
-          AND dep_type IN ('blocks', 'waits-for')
-
-        UNION ALL
-
-        SELECT td.depends_on_id, dt.depth + 1, dt.path || '>' || td.depends_on_id
-        FROM task_dependencies td
-        JOIN dep_tree dt ON td.task_id = dt.id
-        WHERE td.dep_type IN ('blocks', 'waits-for')
-          AND dt.depth < 10
-      )
-      SELECT t.*, dt.depth
-      FROM dep_tree dt
-      JOIN tasks t ON t.id = dt.id
-      ORDER BY dt.depth ASC
-    `);
-    }
-    /**
-     * 获取就绪任务（核心方法）
-     *
-     * 就绪 = status='open' 且无未完成的阻塞型依赖（传递性检测）
-     */
-    getReadyWork(options = {}) {
-        const limit = Math.max(1, Math.min(options.limit || 10, 200));
-        const rows = this._readyStmt.all(limit);
-        return rows.map((r) => Task.fromRow(r)).filter((t) => t !== null);
-    }
-    /**
-     * 获取被阻塞的任务列表
-     * @returns 带 blocked_by 字段的任务列表
-     */
-    getBlockedWork() {
-        const rows = this._blockedStmt.all();
-        return rows.map((r) => ({
-            ...Task.fromRow(r)?.toJSON(),
-            blockedBy: r.blocked_by ? r.blocked_by.split(',') : [],
-        }));
-    }
-    /**
-     * 获取依赖树
-     * @returns 带 depth 的任务列表
-     */
-    getDependencyTree(taskId) {
-        const rows = this._depTreeStmt.all(taskId);
-        return rows.map((r) => ({
-            ...Task.fromRow(r)?.toJSON(),
-            depth: r.depth,
-        }));
-    }
-}
-export default TaskReadyEngine;

package/dist/scripts/build-native-ui.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-/** 在 macOS 上构建 native-ui 辅助程序（可选） */
-export {};

package/dist/scripts/build-native-ui.js

@@ -1,62 +0,0 @@
-#!/usr/bin/env node
-/** 在 macOS 上构建 native-ui 辅助程序（可选） */
-const __dirname = import.meta.dirname;
-import { execSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { PACKAGE_ROOT } from '../lib/shared/package-root.js';
-if (process.platform !== 'darwin') {
-    process.exit(0);
-}
-const root = PACKAGE_ROOT;
-const src = path.join(root, 'resources', 'native-ui', 'main.swift');
-const combinedSrc = path.join(root, 'resources', 'native-ui', 'combined-window.swift');
-const out = path.join(root, 'resources', 'native-ui', 'native-ui');
-// 检查是否在发布流程中（npm publish 会设置 npm_lifecycle_event）
-const isPublishing = process.env.npm_lifecycle_event === 'prepublishOnly';
-try {
-    // 编译 native-ui（包含所有源文件）
-    execSync(`swiftc "${src}" "${combinedSrc}" -o "${out}" -framework AppKit`, {
-        cwd: root,
-        stdio: 'pipe',
-    });
-    // 验证构建结果
-    if (fs.existsSync(out)) {
-    }
-}
-catch (_err) {
-    // 如果在发布流程中构建失败，应该报错
-    if (isPublishing) {
-        console.error('❌ Native UI 构建失败（发布流程中）');
-        console.error('请确保：');
-        console.error('  1. 当前系统是 macOS');
-        console.error('  2. 已安装 Xcode Command Line Tools: xcode-select --install');
-        console.error('  3. Swift 编译器可用: which swiftc');
-        process.exit(1);
-    }
-    // 在用户安装时，如果已有预编译的二进制文件，静默跳过
-    if (fs.existsSync(out)) {
-    }
-    else {
-    }
-}
-// ── 发布流程：最终校验二进制必须存在 ──
-if (isPublishing) {
-    if (!fs.existsSync(out)) {
-        console.error('❌ 发布中止：native-ui 二进制不存在于', out);
-        console.error('   prepublishOnly 编译步骤可能被跳过或失败');
-        process.exit(1);
-    }
-    const stat = fs.statSync(out);
-    if (stat.size < 10_000) {
-        console.error('❌ 发布中止：native-ui 二进制异常（仅', stat.size, '字节）');
-        process.exit(1);
-    }
-    // 确保有执行权限
-    try {
-        fs.chmodSync(out, 0o755);
-    }
-    catch {
-        /* ignore */
-    }
-}

package/dist/scripts/init-snippets.d.ts

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-/**
- * Snippet 统一初始化脚本
- *
- * 为 AutoSnippet 生成快速触发 Snippet（ass/asc/asa）到目标 IDE:
- *   - Xcode: ~/Library/Developer/Xcode/UserData/CodeSnippets/*.codesnippet
- *   - VSCode: .vscode/autosnippet-triggers.code-snippets (项目级)
- *
- * 用法:
- *   node scripts/init-snippets.js [init|list|remove] [--target xcode|vscode|all]
- *   npm run init:snippets
- */
-export declare class SnippetInitializer {
-    vscode: any;
-    xcode: any;
-    constructor(projectRoot: any);
-    /**
-     * 初始化 snippet 到指定目标
-     * @param target — 'xcode' | 'vscode' | 'all'
-     * @returns }
-     */
-    initialize(target?: string): Promise<any>;
-    list(target?: string): any;
-    remove(target?: string): any;
-}
-declare const _default: {
-    SnippetInitializer: typeof SnippetInitializer;
-    initialize: (projectRoot: any, target: any) => Promise<any>;
-};
-export default _default;