autosnippet 2.1.0 → 2.4.0

package/lib/core/session/SessionManager.js

@@ -1,232 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import Logger from '../../infrastructure/logging/Logger.js';
-
-/**
- * SessionManager - 会话管理器
- * 管理不同作用域的会话（project, target, file, developer）
- */
-export class SessionManager {
-  static MAX_CACHED_SESSIONS = 500;
-
-  constructor(db) {
-    this.db = db.getDb();
-    this.logger = Logger.getInstance();
-    this.activeSessions = new Map();
-  }
-
-  /**
-   * 创建会话
-   */
-  create(options) {
-    const sessionId = uuidv4();
-    const {
-      scope,
-      scopeId,
-      context = {},
-      metadata = {},
-      actor = 'unknown',
-    } = options;
-
-    const now = Math.floor(Date.now() / 1000); // UNIX timestamp
-    const expiresAt = now + this._getExpirationSeconds(scope);
-
-    const session = {
-      id: sessionId,
-      scope, // 'project' | 'target' | 'file' | 'developer'
-      scope_id: scopeId,
-      context: JSON.stringify(context),
-      metadata: JSON.stringify(metadata),
-      actor,
-      created_at: now,
-      last_active_at: now,
-      expired_at: expiresAt,
-    };
-
-    // 保存到数据库
-    const stmt = this.db.prepare(`
-      INSERT INTO sessions (id, scope, scope_id, context, metadata, actor, created_at, last_active_at, expired_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-
-    stmt.run(
-      session.id,
-      session.scope,
-      session.scope_id,
-      session.context,
-      session.metadata,
-      session.actor,
-      session.created_at,
-      session.last_active_at,
-      session.expired_at
-    );
-
-    // 加入内存缓存（带上限保护）
-    if (this.activeSessions.size >= SessionManager.MAX_CACHED_SESSIONS) {
-      // 淘汰最老的会话缓存
-      const oldest = this.activeSessions.keys().next().value;
-      this.activeSessions.delete(oldest);
-    }
-    this.activeSessions.set(sessionId, session);
-
-    this.logger.info('Session created', {
-      sessionId,
-      scope,
-      scopeId,
-    });
-
-    return session;
-  }
-
-  /**
-   * 获取会话
-   */
-  get(sessionId) {
-    // 先从缓存获取
-    if (this.activeSessions.has(sessionId)) {
-      const session = this.activeSessions.get(sessionId);
-      if (!this.isExpired(session)) {
-        return session;
-      } else {
-        this.activeSessions.delete(sessionId);
-      }
-    }
-
-    // 从数据库获取
-    const stmt = this.db.prepare('SELECT * FROM sessions WHERE id = ?');
-    const session = stmt.get(sessionId);
-
-    if (session && !this.isExpired(session)) {
-      this.activeSessions.set(sessionId, session);
-      return session;
-    }
-
-    return null;
-  }
-
-  /**
-   * 根据作用域查询会话
-   */
-  findByScope(scope, scopeId) {
-    const stmt = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE scope = ? AND scope_id = ?
-      AND expired_at > ?
-      ORDER BY created_at DESC
-      LIMIT 1
-    `);
-    return stmt.get(scope, scopeId, Math.floor(Date.now() / 1000));
-  }
-
-  /**
-   * 更新会话元数据
-   */
-  updateMetadata(sessionId, metadata) {
-    const now = Math.floor(Date.now() / 1000);
-    const stmt = this.db.prepare(`
-      UPDATE sessions
-      SET metadata = ?, last_active_at = ?
-      WHERE id = ?
-    `);
-
-    stmt.run(
-      JSON.stringify(metadata),
-      now,
-      sessionId
-    );
-
-    // 更新缓存
-    if (this.activeSessions.has(sessionId)) {
-      const session = this.activeSessions.get(sessionId);
-      session.metadata = JSON.stringify(metadata);
-      session.last_active_at = now;
-    }
-
-    this.logger.debug('Session metadata updated', { sessionId });
-  }
-
-  /**
-   * 关闭会话
-   */
-  close(sessionId) {
-    // 直接从数据库删除（更彻底）
-    const stmt = this.db.prepare('DELETE FROM sessions WHERE id = ?');
-    stmt.run(sessionId);
-
-    // 从缓存移除
-    this.activeSessions.delete(sessionId);
-
-    this.logger.info('Session closed', { sessionId });
-  }
-
-  /**
-   * 清理过期会话
-   */
-  cleanupExpired() {
-    const now = Math.floor(Date.now() / 1000);
-    const stmt = this.db.prepare('DELETE FROM sessions WHERE expired_at < ?');
-    const result = stmt.run(now);
-
-    if (result.changes > 0) {
-      this.logger.info(`Cleaned up ${result.changes} expired sessions`);
-    }
-
-    // 清理缓存中的过期会话
-    for (const [sessionId, session] of this.activeSessions.entries()) {
-      if (this.isExpired(session)) {
-        this.activeSessions.delete(sessionId);
-      }
-    }
-  }
-
-  /**
-   * 判断会话是否过期
-   */
-  isExpired(session) {
-    const now = Math.floor(Date.now() / 1000);
-    return session.expired_at < now;
-  }
-
-  /**
-   * 获取作用域的过期秒数
-   */
-  _getExpirationSeconds(scope) {
-    switch (scope) {
-      case 'project':
-        return 7 * 24 * 60 * 60; // 7 天
-      case 'target':
-        return 24 * 60 * 60; // 1 天
-      case 'file':
-        return 60 * 60; // 1 小时
-      case 'developer':
-        return 30 * 24 * 60 * 60; // 30 天
-      default:
-        return 24 * 60 * 60; // 默认 1 天
-    }
-  }
-
-  /**
-   * 获取活跃会话数
-   */
-  getActiveCount() {
-    const now = Math.floor(Date.now() / 1000);
-    const stmt = this.db.prepare('SELECT COUNT(*) as count FROM sessions WHERE expired_at > ?');
-    const result = stmt.get(now);
-    return result.count;
-  }
-
-  /**
-   * 获取所有活跃会话
-   */
-  getActiveSessions(limit = 100) {
-    const now = Math.floor(Date.now() / 1000);
-    const stmt = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE expired_at > ?
-      ORDER BY created_at DESC
-      LIMIT ?
-    `);
-    return stmt.all(now, limit);
-  }
-}
-
-export default SessionManager;

package/lib/infrastructure/logging/ReasoningLogger.js

@@ -1,269 +0,0 @@
-/**
- * ReasoningLogger - 透明推理日志系统
- * 
- * 记录 AI 操作的完整推理过程，包括：
- * - Candidate 提交时的推理上下文
- * - Guard 检查时的规则匹配过程
- * - 搜索时的排名决策
- * 
- * 所有推理日志不可篡改，存储在 SQLite 中
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import Logger from '../logging/Logger.js';
-
-export class ReasoningLogger {
-  constructor(db) {
-    this.db = typeof db?.getDb === 'function' ? db.getDb() : db;
-    this.logger = Logger.getInstance();
-    this._ensureTable();
-  }
-
-  _ensureTable() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS reasoning_logs (
-        id TEXT PRIMARY KEY,
-        type TEXT NOT NULL,
-        actor TEXT NOT NULL,
-        resource_type TEXT,
-        resource_id TEXT,
-        reasoning_json TEXT NOT NULL DEFAULT '{}',
-        quality_score REAL DEFAULT 0,
-        context_json TEXT DEFAULT '{}',
-        created_at INTEGER NOT NULL
-      )
-    `);
-    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_reasoning_logs_type ON reasoning_logs(type)`);
-    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_reasoning_logs_actor ON reasoning_logs(actor)`);
-    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_reasoning_logs_created ON reasoning_logs(created_at)`);
-  }
-
-  /**
-   * 记录 Candidate 推理过程
-   */
-  logCandidateReasoning(candidate, actor, context = {}) {
-    const reasoning = candidate.reasoning || {};
-    const qualityScore = this._assessReasoningQuality(reasoning);
-
-    return this._insert({
-      type: 'candidate_reasoning',
-      actor,
-      resourceType: 'candidate',
-      resourceId: candidate.id,
-      reasoning: {
-        whyStandard: reasoning.whyStandard || '',
-        sources: reasoning.sources || [],
-        qualitySignals: reasoning.qualitySignals || {},
-        alternatives: reasoning.alternatives || [],
-        confidence: reasoning.confidence || 0,
-        assessment: {
-          completeness: this._assessCompleteness(reasoning),
-          sourceQuality: this._assessSourceQuality(reasoning),
-          overall: qualityScore,
-        },
-      },
-      qualityScore,
-      context,
-    });
-  }
-
-  /**
-   * 记录 Guard 规则匹配推理
-   */
-  logGuardReasoning(code, matchedRules, actor, context = {}) {
-    return this._insert({
-      type: 'guard_reasoning',
-      actor,
-      resourceType: 'code_check',
-      resourceId: context.fileId || null,
-      reasoning: {
-        codeLength: code.length,
-        rulesChecked: matchedRules.length,
-        violations: matchedRules.map(r => ({
-          ruleId: r.ruleId || r.id,
-          ruleName: r.name,
-          severity: r.severity,
-          matchCount: r.matches?.length || 0,
-          sourceRecipeId: r.sourceRecipeId,
-        })),
-        checkDuration: context.duration,
-      },
-      qualityScore: 0,
-      context,
-    });
-  }
-
-  /**
-   * 记录搜索排名推理
-   */
-  logSearchReasoning(query, results, rankingFactors, actor, context = {}) {
-    return this._insert({
-      type: 'search_reasoning',
-      actor,
-      resourceType: 'search',
-      resourceId: null,
-      reasoning: {
-        query,
-        resultCount: results.length,
-        topResults: results.slice(0, 5).map(r => ({
-          id: r.id,
-          score: r.score,
-          title: r.title,
-        })),
-        rankingFactors,
-      },
-      qualityScore: 0,
-      context,
-    });
-  }
-
-  /**
-   * 查询推理日志
-   */
-  query(filters = {}, pagination = { page: 1, pageSize: 20 }) {
-    const conditions = ['1=1'];
-    const params = [];
-
-    if (filters.type) {
-      conditions.push('type = ?');
-      params.push(filters.type);
-    }
-    if (filters.actor) {
-      conditions.push('actor = ?');
-      params.push(filters.actor);
-    }
-    if (filters.resourceType) {
-      conditions.push('resource_type = ?');
-      params.push(filters.resourceType);
-    }
-    if (filters.resourceId) {
-      conditions.push('resource_id = ?');
-      params.push(filters.resourceId);
-    }
-    if (filters.minQuality !== undefined) {
-      conditions.push('quality_score >= ?');
-      params.push(filters.minQuality);
-    }
-    if (filters.since) {
-      conditions.push('created_at >= ?');
-      params.push(filters.since);
-    }
-
-    const offset = (pagination.page - 1) * pagination.pageSize;
-    const where = conditions.join(' AND ');
-
-    const rows = this.db.prepare(
-      `SELECT * FROM reasoning_logs WHERE ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`
-    ).all(...params, pagination.pageSize, offset);
-
-    const countRow = this.db.prepare(
-      `SELECT COUNT(*) as total FROM reasoning_logs WHERE ${where}`
-    ).get(...params);
-
-    return {
-      items: rows.map(this._mapRow),
-      total: countRow.total,
-      page: pagination.page,
-      pageSize: pagination.pageSize,
-    };
-  }
-
-  /**
-   * 获取推理质量统计
-   */
-  getQualityStats(since = null) {
-    const params = [];
-    let where = '1=1';
-    if (since) {
-      where = 'created_at >= ?';
-      params.push(since);
-    }
-
-    const stats = this.db.prepare(`
-      SELECT 
-        type,
-        COUNT(*) as count,
-        AVG(quality_score) as avg_quality,
-        MIN(quality_score) as min_quality,
-        MAX(quality_score) as max_quality
-      FROM reasoning_logs 
-      WHERE ${where}
-      GROUP BY type
-    `).all(...params);
-
-    return stats;
-  }
-
-  // ========== Private Methods ==========
-
-  _insert({ type, actor, resourceType, resourceId, reasoning, qualityScore, context }) {
-    const id = uuidv4();
-    const now = Math.floor(Date.now() / 1000);
-
-    this.db.prepare(`
-      INSERT INTO reasoning_logs (id, type, actor, resource_type, resource_id, reasoning_json, quality_score, context_json, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, type, actor, resourceType, resourceId, JSON.stringify(reasoning), qualityScore, JSON.stringify(context), now);
-
-    return { id, type, actor, qualityScore, createdAt: now };
-  }
-
-  _mapRow(row) {
-    return {
-      id: row.id,
-      type: row.type,
-      actor: row.actor,
-      resourceType: row.resource_type,
-      resourceId: row.resource_id,
-      reasoning: JSON.parse(row.reasoning_json || '{}'),
-      qualityScore: row.quality_score,
-      context: JSON.parse(row.context_json || '{}'),
-      createdAt: row.created_at,
-    };
-  }
-
-  /**
-   * 评估推理质量（0-1）
-   */
-  _assessReasoningQuality(reasoning) {
-    if (!reasoning) return 0;
-
-    const completeness = this._assessCompleteness(reasoning);
-    const sourceQuality = this._assessSourceQuality(reasoning);
-    const confidenceScore = typeof reasoning.confidence === 'number' ? reasoning.confidence : 0;
-
-    // 权重: 完整性 40%, 来源质量 35%, 置信度 25%
-    return Math.round((completeness * 0.4 + sourceQuality * 0.35 + confidenceScore * 0.25) * 100) / 100;
-  }
-
-  _assessCompleteness(reasoning) {
-    if (!reasoning) return 0;
-    let score = 0;
-    if (reasoning.whyStandard && reasoning.whyStandard.length > 10) score += 0.3;
-    if (Array.isArray(reasoning.sources) && reasoning.sources.length > 0) score += 0.25;
-    if (reasoning.qualitySignals && Object.keys(reasoning.qualitySignals).length > 0) score += 0.2;
-    if (Array.isArray(reasoning.alternatives) && reasoning.alternatives.length > 0) score += 0.15;
-    if (typeof reasoning.confidence === 'number') score += 0.1;
-    return Math.min(1, score);
-  }
-
-  _assessSourceQuality(reasoning) {
-    if (!reasoning || !Array.isArray(reasoning.sources) || reasoning.sources.length === 0) return 0;
-    // 多来源 + 来源有类型或链接 → 较高质量
-    const count = Math.min(reasoning.sources.length, 5);
-    return count / 5;
-  }
-}
-
-let instance = null;
-
-export function initReasoningLogger(db) {
-  instance = new ReasoningLogger(db);
-  return instance;
-}
-
-export function getReasoningLogger() {
-  return instance;
-}
-
-export default ReasoningLogger;