autosnippet 3.2.21 → 3.3.2

package/dist/lib/repository/task/TaskRepository.impl.js

@@ -1,347 +0,0 @@
-import { and, asc, eq, sql } from 'drizzle-orm';
-import { Task } from '../../domain/task/Task.js';
-import { getDrizzle } from '../../infrastructure/database/drizzle/index.js';
-import { taskDependencies, taskEvents, tasks, } from '../../infrastructure/database/drizzle/schema.js';
-import Logger from '../../infrastructure/logging/Logger.js';
-/**
- * TaskRepositoryImpl — 任务实体 SQLite 持久化 (Drizzle ORM)
- *
- * DB 列名 snake_case，实体属性 camelCase—— Task.fromRow() / _entityToRow() 负责映射。
- *
- * Drizzle 迁移策略：
- * - CRUD (create/findById/update/delete) → drizzle 类型安全 API
- * - 依赖管理 (add/remove/get) → drizzle 类型安全 API
- * - 事件审计 / 统计 → drizzle 类型安全 API
- * - 环检测 (递归 CTE) / 复杂动态查询 (findAll) → 保留 raw SQL
- */
-export class TaskRepositoryImpl {
-    _reachableStmt;
-    #drizzle;
-    db;
-    logger;
-    constructor(database, drizzle) {
-        this.db = database.getDb();
-        this.logger = Logger.getInstance();
-        this.#drizzle = drizzle ?? getDrizzle();
-        this._prepareStatements();
-    }
-    /** 预编译复杂查询（仅保留 drizzle 无法表达的递归 CTE） */
-    _prepareStatements() {
-        // ── 环检测 (递归 CTE) — drizzle 不支持递归 CTE ──
-        this._reachableStmt = this.db.prepare(`
-      WITH RECURSIVE reachable(id, depth) AS (
-        SELECT depends_on_id, 1
-        FROM task_dependencies
-        WHERE task_id = ?
-          AND dep_type IN ('blocks', 'waits-for')
-
-        UNION ALL
-
-        SELECT td.depends_on_id, r.depth + 1
-        FROM task_dependencies td
-        JOIN reachable r ON td.task_id = r.id
-        WHERE td.dep_type IN ('blocks', 'waits-for')
-          AND r.depth < 50
-      )
-      SELECT 1 FROM reachable WHERE id = ? LIMIT 1
-    `);
-    }
-    // ═══ CRUD ═══════════════════════════════════════════
-    /**
-     * 创建任务
-     * ★ Drizzle 类型安全 INSERT
-     */
-    create(task) {
-        const row = this._entityToRow(task);
-        this.#drizzle.insert(tasks).values(row).run();
-        return this.findById(task.id);
-    }
-    /**
-     * 按 ID 查询
-     * ★ Drizzle 类型安全 SELECT
-     */
-    findById(id) {
-        const row = this.#drizzle.select().from(tasks).where(eq(tasks.id, id)).get();
-        return row ? Task.fromRow(row) : null;
-    }
-    /**
-     * 按内容哈希查询（去重用）
-     * ★ Drizzle 类型安全 SELECT
-     */
-    findByContentHash(hash) {
-        if (!hash) {
-            return null;
-        }
-        const row = this.#drizzle
-            .select()
-            .from(tasks)
-            .where(and(eq(tasks.contentHash, hash), sql `${tasks.status} != 'closed'`))
-            .get();
-        return row ? Task.fromRow(row) : null;
-    }
-    /**
-     * 更新任务字段
-     * ★ Drizzle 类型安全 UPDATE
-     */
-    update(id, fields) {
-        const setObj = {};
-        const columnMap = {
-            status: 'status',
-            priority: 'priority',
-            assignee: 'assignee',
-            notes: 'notes',
-            description: 'description',
-            design: 'design',
-            acceptance: 'acceptance',
-            closeReason: 'closeReason',
-            closedAt: 'closedAt',
-            updatedAt: 'updatedAt',
-            failCount: 'failCount',
-            lastFailReason: 'lastFailReason',
-            childSeq: 'childSeq',
-            metadata: 'metadata',
-        };
-        for (const [key, value] of Object.entries(fields)) {
-            const schemaKey = columnMap[key];
-            if (!schemaKey) {
-                continue;
-            }
-            setObj[schemaKey] = key === 'metadata' ? JSON.stringify(value) : value;
-        }
-        if (Object.keys(setObj).length === 0) {
-            return this.findById(id);
-        }
-        // 始终更新 updatedAt
-        if (!fields.updatedAt) {
-            setObj.updatedAt = Math.floor(Date.now() / 1000);
-        }
-        this.#drizzle.update(tasks).set(setObj).where(eq(tasks.id, id)).run();
-        return this.findById(id);
-    }
-    /**
-     * 删除任务
-     * ★ Drizzle 类型安全 DELETE
-     */
-    delete(id) {
-        const result = this.#drizzle.delete(tasks).where(eq(tasks.id, id)).run();
-        return result.changes > 0;
-    }
-    /**
-     * 列表查询
-     * @param filters { status, taskType, assignee, parentId }
-     * @param options { limit, offset, orderBy }
-     */
-    findAll(filters = {}, options = {}) {
-        const conditions = [];
-        const params = [];
-        if (filters.status) {
-            conditions.push('status = ?');
-            params.push(filters.status);
-        }
-        if (filters.taskType) {
-            conditions.push('task_type = ?');
-            params.push(filters.taskType);
-        }
-        if (filters.assignee) {
-            conditions.push('assignee = ?');
-            params.push(filters.assignee);
-        }
-        if (filters.parentId) {
-            conditions.push('parent_id = ?');
-            params.push(filters.parentId);
-        }
-        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-        const limit = Math.max(1, Math.min(options.limit || 50, 500));
-        const offset = Math.max(0, options.offset || 0);
-        const orderBy = _sanitizeOrderBy(options.orderBy);
-        const sql = `SELECT * FROM tasks ${where} ORDER BY ${orderBy} LIMIT ? OFFSET ?`;
-        params.push(limit, offset);
-        const rows = this.db.prepare(sql).all(...params);
-        return rows.map((r) => Task.fromRow(r));
-    }
-    // ═══ 依赖管理 ═══════════════════════════════════════
-    /**
-     * 添加依赖
-     * ★ Drizzle 类型安全 INSERT OR IGNORE
-     */
-    addDependency(taskId, dependsOnId, depType) {
-        this.#drizzle
-            .insert(taskDependencies)
-            .values({
-            taskId,
-            dependsOnId,
-            depType,
-            createdAt: Math.floor(Date.now() / 1000),
-            createdBy: 'agent',
-        })
-            .onConflictDoNothing()
-            .run();
-    }
-    /**
-     * 删除依赖
-     * ★ Drizzle 类型安全 DELETE
-     */
-    removeDependency(taskId, dependsOnId, depType) {
-        this.#drizzle
-            .delete(taskDependencies)
-            .where(and(eq(taskDependencies.taskId, taskId), eq(taskDependencies.dependsOnId, dependsOnId), eq(taskDependencies.depType, depType)))
-            .run();
-    }
-    /**
-     * 获取任务的所有依赖
-     * ★ Drizzle 类型安全 SELECT
-     */
-    getDependencies(taskId) {
-        return this.#drizzle
-            .select()
-            .from(taskDependencies)
-            .where(eq(taskDependencies.taskId, taskId))
-            .orderBy(asc(taskDependencies.createdAt))
-            .all();
-    }
-    /**
-     * 获取依赖此任务的所有任务
-     * ★ Drizzle 类型安全 SELECT
-     */
-    getDependents(dependsOnId) {
-        return this.#drizzle
-            .select()
-            .from(taskDependencies)
-            .where(eq(taskDependencies.dependsOnId, dependsOnId))
-            .all();
-    }
-    /**
-     * 获取阻塞某任务的所有任务（含任务详情）
-     * 保留 raw SQL — JOIN 查询
-     */
-    getBlockers(taskId) {
-        const rows = this.db
-            .prepare(`
-      SELECT t.*
-      FROM task_dependencies td
-      JOIN tasks t ON td.depends_on_id = t.id
-      WHERE td.task_id = ?
-        AND td.dep_type IN ('blocks', 'waits-for')
-        AND t.status != 'closed'
-    `)
-            .all(taskId);
-        return rows.map((r) => Task.fromRow(r));
-    }
-    /** 环检测：检查 fromId → toId 是否已有可达路径 */
-    hasReachablePath(fromId, toId) {
-        const row = this._reachableStmt.get(fromId, toId);
-        return !!row;
-    }
-    // ═══ 事务支持 ═══════════════════════════════════════
-    /** 在事务中执行操作 */
-    inTransaction(fn) {
-        const txn = this.db.transaction(fn);
-        return txn();
-    }
-    // ═══ 统计 ═══════════════════════════════════════════
-    /**
-     * 获取任务统计
-     * 保留 raw SQL — SUM(CASE WHEN) 聚合在 drizzle 中不如直写清晰
-     */
-    getStatistics() {
-        const row = this.db
-            .prepare(`
-      SELECT
-        COUNT(*)                                           as total,
-        SUM(CASE WHEN status = 'open'        THEN 1 ELSE 0 END) as open,
-        SUM(CASE WHEN status = 'in_progress' THEN 1 ELSE 0 END) as in_progress,
-        SUM(CASE WHEN status = 'closed'      THEN 1 ELSE 0 END) as closed,
-        SUM(CASE WHEN status = 'deferred'    THEN 1 ELSE 0 END) as deferred,
-        SUM(CASE WHEN status = 'pinned'      THEN 1 ELSE 0 END) as pinned
-      FROM tasks
-    `)
-            .get();
-        return {
-            total: row.total || 0,
-            open: row.open || 0,
-            in_progress: row.in_progress || 0,
-            closed: row.closed || 0,
-            deferred: row.deferred || 0,
-            pinned: row.pinned || 0,
-        };
-    }
-    // ═══ 事件审计 ═══════════════════════════════════════
-    /**
-     * 记录任务事件
-     * ★ Drizzle 类型安全 INSERT
-     */
-    logEvent(taskId, eventType, oldValue = null, newValue = null, comment = null, actor = 'agent') {
-        this.#drizzle
-            .insert(taskEvents)
-            .values({
-            taskId,
-            eventType,
-            actor,
-            oldValue,
-            newValue,
-            comment,
-            createdAt: Math.floor(Date.now() / 1000),
-        })
-            .run();
-    }
-    // ═══ 私有方法 ═══════════════════════════════════════
-    /** 实体 → DB 行 (camelCase → snake_case) */
-    _entityToRow(task) {
-        return {
-            id: task.id,
-            parentId: task.parentId || null,
-            childSeq: task.childSeq || 0,
-            title: task.title,
-            description: task.description || '',
-            design: task.design || '',
-            acceptance: task.acceptance || '',
-            notes: task.notes || '',
-            status: task.status,
-            priority: task.priority ?? 2,
-            taskType: task.taskType || 'task',
-            closeReason: task.closeReason || '',
-            contentHash: task.contentHash || '',
-            failCount: task.failCount || 0,
-            lastFailReason: task.lastFailReason || '',
-            assignee: task.assignee || '',
-            createdBy: task.createdBy || 'agent',
-            createdAt: task.createdAt,
-            updatedAt: task.updatedAt,
-            closedAt: task.closedAt || null,
-            metadata: JSON.stringify(task.metadata || {}),
-        };
-    }
-}
-// ═══ 内部工具 ═══════════════════════════════════════
-const ALLOWED_ORDER_FIELDS = new Set([
-    'priority',
-    'created_at',
-    'updated_at',
-    'status',
-    'title',
-    'task_type',
-    'closed_at',
-]);
-const ALLOWED_DIRECTIONS = new Set(['ASC', 'DESC']);
-/** orderBy 白名单校验，防止 SQL 注入 */
-function _sanitizeOrderBy(orderBy) {
-    if (!orderBy) {
-        return 'priority ASC, created_at ASC';
-    }
-    return (orderBy
-        .split(',')
-        .map((clause) => {
-        const parts = clause.trim().split(/\s+/);
-        const field = parts[0];
-        if (!ALLOWED_ORDER_FIELDS.has(field)) {
-            return null;
-        }
-        const dir = ALLOWED_DIRECTIONS.has(parts[1]?.toUpperCase())
-            ? parts[1].toUpperCase()
-            : 'ASC';
-        return `${field} ${dir}`;
-    })
-        .filter(Boolean)
-        .join(', ') || 'priority ASC, created_at ASC');
-}
-export default TaskRepositoryImpl;

package/dist/lib/service/automation/ActionPipeline.d.ts

@@ -1,34 +0,0 @@
-/**
- * ActionPipeline — 自动化动作管线
- * 按顺序执行注册的 action handlers
- */
-export declare class ActionPipeline {
-    #private;
-    constructor();
-    /**
-     * 注册动作处理器
-     * @param type 触发类型
-     * @param handler async (trigger, context) => result
-     */
-    register(type: string, handler: (trigger: Record<string, unknown>, context: Record<string, unknown>) => Promise<unknown>): void;
-    /**
-     * 执行管线
-     * @param trigger
-     * @returns >}
-     */
-    execute(trigger: {
-        type: string;
-        name?: string;
-        params?: Record<string, unknown>;
-    }, context: Record<string, unknown>): Promise<{
-        success: boolean;
-        result: unknown;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        result?: undefined;
-    }>;
-    /** 获取已注册的动作类型 */
-    getRegisteredTypes(): any[];
-}

package/dist/lib/service/automation/ActionPipeline.js

@@ -1,53 +0,0 @@
-/**
- * ActionPipeline — 自动化动作管线
- * 按顺序执行注册的 action handlers
- */
-import Logger from '../../infrastructure/logging/Logger.js';
-export class ActionPipeline {
-    #actions; // Map<type, handler>
-    #logger;
-    constructor() {
-        this.#actions = new Map();
-        this.#logger = Logger.getInstance();
-    }
-    /**
-     * 注册动作处理器
-     * @param type 触发类型
-     * @param handler async (trigger, context) => result
-     */
-    register(type, handler) {
-        this.#actions.set(type, handler);
-    }
-    /**
-     * 执行管线
-     * @param trigger
-     * @returns >}
-     */
-    async execute(trigger, context) {
-        const handler = this.#actions.get(trigger.type);
-        if (!handler) {
-            // 尝试通用 handler
-            const fallback = this.#actions.get('*');
-            if (fallback) {
-                return this.#runHandler(fallback, trigger, context);
-            }
-            this.#logger.warn(`[ActionPipeline] 未找到 handler: ${trigger.type}`);
-            return { success: false, error: `未知触发类型: ${trigger.type}` };
-        }
-        return this.#runHandler(handler, trigger, context);
-    }
-    /** 获取已注册的动作类型 */
-    getRegisteredTypes() {
-        return [...this.#actions.keys()];
-    }
-    async #runHandler(handler, trigger, context) {
-        try {
-            const result = await handler(trigger, context);
-            return { success: true, result };
-        }
-        catch (err) {
-            this.#logger.error(`[ActionPipeline] handler 异常:`, err.message);
-            return { success: false, error: err.message };
-        }
-    }
-}

package/dist/lib/service/automation/AutomationOrchestrator.d.ts

@@ -1,86 +0,0 @@
-/**
- * AutomationOrchestrator — 自动化编排器
- * 整合 TriggerResolver + ContextCollector + ActionPipeline
- */
-import { ActionPipeline } from './ActionPipeline.js';
-import { ContextCollector } from './ContextCollector.js';
-import { TriggerResolver } from './TriggerResolver.js';
-export declare class AutomationOrchestrator {
-    #private;
-    constructor(options?: {
-        triggerResolver?: TriggerResolver;
-        contextCollector?: ContextCollector;
-        pipeline?: ActionPipeline;
-    });
-    /**
-     * 执行自动化流程
-     * @param trigger 原始触发
-     * @param context 原始上下文
-     * @returns >}
-     */
-    run(trigger: string | Record<string, unknown>, context?: Record<string, unknown>): Promise<{
-        resolvedTrigger: {
-            type: string;
-            name: string;
-            params: {
-                option: string;
-            };
-            raw: string;
-        } | {
-            type: string;
-            name: string;
-            params: {
-                option?: undefined;
-            };
-            raw: string;
-        } | {
-            type: string;
-            name: string;
-            params: Record<string, unknown>;
-            raw: Record<string, unknown>;
-        } | {
-            type: string;
-            raw: never;
-            name?: undefined;
-            params?: undefined;
-        };
-        success: boolean;
-        result: unknown;
-        error?: undefined;
-    } | {
-        resolvedTrigger: {
-            type: string;
-            name: string;
-            params: {
-                option: string;
-            };
-            raw: string;
-        } | {
-            type: string;
-            name: string;
-            params: {
-                option?: undefined;
-            };
-            raw: string;
-        } | {
-            type: string;
-            name: string;
-            params: Record<string, unknown>;
-            raw: Record<string, unknown>;
-        } | {
-            type: string;
-            raw: never;
-            name?: undefined;
-            params?: undefined;
-        };
-        success: boolean;
-        error: string;
-        result?: undefined;
-    }>;
-    /** 注册动作处理器 */
-    registerAction(type: string, handler: (trigger: Record<string, unknown>, context: Record<string, unknown>) => Promise<unknown>): void;
-    /** 获取执行历史 */
-    getHistory(): Record<string, unknown>[];
-    /** 获取管线 */
-    getPipeline(): ActionPipeline;
-}

package/dist/lib/service/automation/AutomationOrchestrator.js

@@ -1,57 +0,0 @@
-/**
- * AutomationOrchestrator — 自动化编排器
- * 整合 TriggerResolver + ContextCollector + ActionPipeline
- */
-import Logger from '../../infrastructure/logging/Logger.js';
-import { ActionPipeline } from './ActionPipeline.js';
-import { ContextCollector } from './ContextCollector.js';
-import { TriggerResolver } from './TriggerResolver.js';
-export class AutomationOrchestrator {
-    #triggerResolver;
-    #contextCollector;
-    #pipeline;
-    #logger;
-    #history;
-    constructor(options = {}) {
-        this.#triggerResolver = options.triggerResolver || new TriggerResolver();
-        this.#contextCollector = options.contextCollector || new ContextCollector();
-        this.#pipeline = options.pipeline || new ActionPipeline();
-        this.#logger = Logger.getInstance();
-        this.#history = [];
-    }
-    /**
-     * 执行自动化流程
-     * @param trigger 原始触发
-     * @param context 原始上下文
-     * @returns >}
-     */
-    async run(trigger, context = {}) {
-        const resolvedTrigger = this.#triggerResolver.resolve(trigger);
-        const collectedContext = this.#contextCollector.collect(context);
-        this.#logger.info(`[AutomationOrchestrator] run type=${resolvedTrigger.type} name=${resolvedTrigger.name || ''}`);
-        const pipelineResult = await this.#pipeline.execute(resolvedTrigger, collectedContext);
-        const record = {
-            trigger: resolvedTrigger,
-            context: { filePath: collectedContext.filePath, language: collectedContext.language },
-            result: pipelineResult,
-            timestamp: new Date().toISOString(),
-        };
-        this.#history.push(record);
-        if (this.#history.length > 200) {
-            this.#history = this.#history.slice(-200);
-        }
-        return { ...pipelineResult, resolvedTrigger };
-    }
-    /** 注册动作处理器 */
-    registerAction(type, handler) {
-        this.#pipeline.register(type, handler);
-    }
-    /** 获取执行历史 */
-    getHistory() {
-        return [...this.#history];
-    }
-    /** 获取管线 */
-    getPipeline() {
-        return this.#pipeline;
-    }
-}

package/dist/lib/service/automation/ContextCollector.d.ts

@@ -1,24 +0,0 @@
-/**
- * ContextCollector — 自动化上下文收集器
- * 收集并规范化自动化执行所需的上下文信息
- */
-export declare class ContextCollector {
-    #private;
-    /**
-     * 收集上下文
-     * @param rawContext 原始上下文
-     * @returns 规范化的上下文
-     */
-    collect(rawContext?: Record<string, unknown>): {
-        filePath: {} | null;
-        content: {} | null;
-        language: {} | null;
-        projectRoot: {} | null;
-        user: {};
-        timestamp: string;
-        environment: {
-            platform: NodeJS.Platform;
-            nodeVersion: string;
-        };
-    };
-}

package/dist/lib/service/automation/ContextCollector.js

@@ -1,35 +0,0 @@
-/**
- * ContextCollector — 自动化上下文收集器
- * 收集并规范化自动化执行所需的上下文信息
- */
-import { LanguageService } from '../../shared/LanguageService.js';
-export class ContextCollector {
-    /**
-     * 收集上下文
-     * @param rawContext 原始上下文
-     * @returns 规范化的上下文
-     */
-    collect(rawContext = {}) {
-        return {
-            ...rawContext,
-            filePath: rawContext.filePath || null,
-            content: rawContext.content || null,
-            language: rawContext.language ||
-                this.#detectLanguage(rawContext.filePath),
-            projectRoot: rawContext.projectRoot || null,
-            user: rawContext.user || 'default',
-            timestamp: new Date().toISOString(),
-            environment: {
-                platform: process.platform,
-                nodeVersion: process.version,
-            },
-        };
-    }
-    #detectLanguage(filePath) {
-        if (!filePath) {
-            return null;
-        }
-        const lang = LanguageService.inferLang(filePath);
-        return lang === 'unknown' ? null : lang;
-    }
-}

package/dist/lib/service/automation/DirectiveDetector.d.ts

@@ -1,51 +0,0 @@
-/**
- * DirectiveDetector - 文件内指令检测器
- *
- * 检测 // as:c（创建）、// as:s（搜索）、// as:a（审计）等指令
- * V2 ESM 版本，对应 V1 DirectiveDetector.js
- */
-/** 指令标记常量 */
-export declare const MARKS: {
-    HEADER_INCLUDE: string;
-    HEADER_IMPORT: string;
-    HEADER_INCLUDE_SHORT: string;
-    HEADER_IMPORT_SHORT: string;
-    CREATE_SHORT: string;
-    CREATE_ALIAS: string;
-    AUDIT_SHORT: string;
-    AUDIT_ALIAS: string;
-    SEARCH_SHORT: string;
-    SEARCH_LONG: string;
-    SEARCH_ALIAS: string;
-    ALINK: string;
-};
-/** 正则表达式 */
-export declare const REGEX: {
-    CREATE_LINE: RegExp;
-    CREATE_REMOVE: RegExp;
-    HEADER_OBJC: RegExp;
-    HEADER_SWIFT: RegExp;
-    IMPORT_OBJC: RegExp;
-    IMPORT_SWIFT: RegExp;
-    SEARCH_MARK: RegExp;
-};
-/**
- * 检测文件内容中的所有触发指令
- *
- * @param data 文件内容
- * @param filename 文件名
- * @returns {{ importArray: string[], headerLine: string|null, alinkLine: string|null,
- *             createLine: string|null, createOption: string|null,
- *             guardLine: string|null, searchLine: string|null, isSwift: boolean, language: string }}
- */
-export declare function detectTriggers(data: string, filename: string): {
-    importArray: string[];
-    headerLine: string | null;
-    alinkLine: string | null;
-    createLine: string | null;
-    createOption: string | null;
-    guardLine: string | null;
-    searchLine: string | null;
-    isSwift: boolean;
-    language: string;
-};