evo-skills 0.1.0

package/src/core/shadow-manager/index.ts

@@ -0,0 +1,278 @@
+import { createChildLogger } from '../../utils/logger.js';
+import { configManager } from '../../config/index.js';
+import { createShadowRegistry } from '../shadow-registry/index.js';
+import { createJournalManager } from '../journal/index.js';
+import { createTraceManager } from '../observer/trace-manager.js';
+import { evaluator } from '../evaluator/index.js';
+import { patchGenerator } from '../patch-generator/index.js';
+import { hashString } from '../../utils/hash.js';
+import type { Trace, EvaluationResult, AutoOptimizePolicy } from '../../types/index.js';
+
+const logger = createChildLogger('shadow-manager');
+
+/**
+ * Shadow Manager
+ * 负责编排整个演化流程
+ */
+export class ShadowManager {
+  private shadowRegistry;
+  private journalManager;
+  private traceManager;
+  private policy: AutoOptimizePolicy;
+  private lastPatchTime: Map<string, number> = new Map();
+  private patchCountToday: Map<string, number> = new Map();
+
+  constructor(projectRoot: string) {
+    this.shadowRegistry = createShadowRegistry(projectRoot);
+    this.journalManager = createJournalManager(projectRoot);
+    this.traceManager = createTraceManager(projectRoot);
+
+    const patchConfig = configManager.getPatchConfig();
+    this.policy = {
+      min_signal_count: configManager.getEvaluatorConfig().min_signal_count,
+      min_source_sessions: configManager.getEvaluatorConfig().min_source_sessions,
+      min_confidence: configManager.getEvaluatorConfig().min_confidence,
+      cooldown_hours: patchConfig.cooldown_hours,
+      max_patches_per_day: patchConfig.max_patches_per_day,
+      pause_after_rollback_hours: 48,
+    };
+  }
+
+  /**
+   * 初始化
+   */
+  async init(): Promise<void> {
+    await this.shadowRegistry.init();
+    await this.journalManager.init();
+    await this.traceManager.init();
+    logger.info('Shadow manager initialized');
+  }
+
+  /**
+   * 处理 trace
+   */
+  async processTrace(trace: Trace): Promise<void> {
+    // 记录 trace
+    this.traceManager.recordTrace(trace);
+
+    // 检查是否需要触发评估
+    const shadowId = await this.findShadowForTrace(trace);
+    if (!shadowId) {
+      return;
+    }
+
+    // 获取最近的 traces
+    const recentTraces = await this.traceManager.getSessionTraces(trace.session_id);
+
+    // 评估是否需要优化
+    const evaluation = evaluator.evaluate(recentTraces);
+
+    if (evaluation && evaluation.should_patch) {
+      await this.handleEvaluation(shadowId, evaluation, recentTraces);
+    }
+  }
+
+  /**
+   * 查找 trace 对应的 shadow
+   */
+  private async findShadowForTrace(_trace: Trace): Promise<string | null> {
+    // 这里需要根据 trace 的内容推断对应的 skill
+    // 简化实现：返回 null，实际需要更复杂的逻辑
+    return null;
+  }
+
+  /**
+   * 处理评估结果
+   */
+  private async handleEvaluation(
+    shadowId: string,
+    evaluation: EvaluationResult,
+    _traces: Trace[]
+  ): Promise<void> {
+    // 检查是否在冷却期
+    if (this.isInCooldown(shadowId)) {
+      logger.debug(`Shadow ${shadowId} is in cooldown, skipping patch`);
+      return;
+    }
+
+    // 检查是否超过每日限制
+    if (this.exceedsDailyLimit(shadowId)) {
+      logger.debug(`Shadow ${shadowId} exceeds daily patch limit, skipping`);
+      return;
+    }
+
+    // 检查是否被冻结
+    const shadow = await this.shadowRegistry.get(shadowId.split('@')[0]);
+    if (shadow?.status === 'frozen') {
+      logger.debug(`Shadow ${shadowId} is frozen, skipping patch`);
+      return;
+    }
+
+    // 检查置信度
+    if (evaluation.confidence < this.policy.min_confidence) {
+      logger.debug(`Confidence ${evaluation.confidence} below threshold, skipping patch`);
+      return;
+    }
+
+    // 执行 patch
+    await this.executePatch(shadowId, evaluation);
+  }
+
+  /**
+   * 执行 patch
+   */
+  private async executePatch(shadowId: string, evaluation: EvaluationResult): Promise<void> {
+    const skillId = shadowId.split('@')[0];
+
+    try {
+      // 读取当前内容
+      const currentContent = await this.shadowRegistry.readContent(skillId);
+      if (!currentContent) {
+        logger.warn(`Cannot read shadow content: ${skillId}`);
+        return;
+      }
+
+      // 生成 patch
+      const context = {
+        pattern: evaluation.reason,
+        reason: evaluation.reason,
+        section: evaluation.target_section,
+      };
+
+      const patchResult = patchGenerator.generate(
+        evaluation.change_type!,
+        currentContent,
+        context
+      );
+
+      if (!patchResult.success) {
+        logger.warn(`Patch generation failed: ${patchResult.error}`);
+        return;
+      }
+
+      // 获取当前 revision
+      const currentRevision = await this.journalManager.getLatestRevision(shadowId);
+
+      // 写入新内容
+      await this.shadowRegistry.writeContent(skillId, patchResult.newContent);
+
+      // 记录演化
+      await this.journalManager.record(shadowId, {
+        shadow_id: shadowId,
+        timestamp: new Date().toISOString(),
+        reason: evaluation.reason ?? 'Auto optimization',
+        source_sessions: evaluation.source_sessions,
+        change_type: evaluation.change_type!,
+        patch: patchResult.patch,
+        before_hash: hashString(currentContent),
+        after_hash: hashString(patchResult.newContent),
+        applied_by: 'auto',
+      });
+
+      // 更新时间戳
+      this.lastPatchTime.set(shadowId, Date.now());
+
+      // 更新计数
+      const today = new Date().toDateString();
+      const key = `${shadowId}:${today}`;
+      this.patchCountToday.set(key, (this.patchCountToday.get(key) ?? 0) + 1);
+
+      // 检查是否需要创建 snapshot
+      if (evaluation.change_type === 'rewrite_section' || (currentRevision + 1) % 5 === 0) {
+        await this.journalManager.createSnapshot(shadowId, currentRevision + 1);
+      }
+
+      logger.info(`Patch executed successfully`, {
+        shadow_id: shadowId,
+        change_type: evaluation.change_type,
+        revision: currentRevision + 1,
+      });
+    } catch (error) {
+      logger.error(`Patch execution failed`, { shadow_id: shadowId, error });
+    }
+  }
+
+  /**
+   * 检查是否在冷却期
+   */
+  private isInCooldown(shadowId: string): boolean {
+    const lastTime = this.lastPatchTime.get(shadowId);
+    if (!lastTime) {
+      return false;
+    }
+
+    const cooldownMs = this.policy.cooldown_hours * 60 * 60 * 1000;
+    return Date.now() - lastTime < cooldownMs;
+  }
+
+  /**
+   * 检查是否超过每日限制
+   */
+  private exceedsDailyLimit(shadowId: string): boolean {
+    const today = new Date().toDateString();
+    const key = `${shadowId}:${today}`;
+    const count = this.patchCountToday.get(key) ?? 0;
+    return count >= this.policy.max_patches_per_day;
+  }
+
+  /**
+   * 手动触发优化
+   */
+  async triggerOptimize(shadowId: string): Promise<EvaluationResult | null> {
+    // 获取最近的 traces
+    const traces = await this.traceManager.getRecentTraces(100);
+
+    // 评估
+    const evaluation = evaluator.evaluate(traces);
+
+    if (evaluation && evaluation.should_patch) {
+      await this.executePatch(shadowId, evaluation);
+    }
+
+    return evaluation;
+  }
+
+  /**
+   * 获取 shadow 状态
+   */
+  async getShadowState(shadowId: string) {
+    const skillId = shadowId.split('@')[0];
+    const shadow = await this.shadowRegistry.get(skillId);
+
+    if (!shadow) {
+      return null;
+    }
+
+    const latestRevision = await this.journalManager.getLatestRevision(shadowId);
+    const snapshots = await this.journalManager.getSnapshots(shadowId);
+
+    return {
+      shadow,
+      latest_revision: latestRevision,
+      snapshot_count: snapshots.length,
+      last_patch_time: this.lastPatchTime.get(shadowId),
+    };
+  }
+
+  /**
+   * 清理旧 traces
+   */
+  async cleanupOldTraces(retentionDays: number): Promise<number> {
+    return this.traceManager.cleanupOldTraces(retentionDays);
+  }
+
+  /**
+   * 关闭
+   */
+  close(): void {
+    this.shadowRegistry.close();
+    this.journalManager.close();
+    this.traceManager.close();
+    logger.info('Shadow manager closed');
+  }
+}
+
+// 导出工厂函数
+export function createShadowManager(projectRoot: string): ShadowManager {
+  return new ShadowManager(projectRoot);
+}

package/src/core/shadow-registry/index.ts

@@ -0,0 +1,200 @@
+import { mkdirSync, existsSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createChildLogger } from '../../utils/logger.js';
+import { getShadowSkillPath, getShadowMetaPath, getShadowJournalPath, getSnapshotsDir } from '../../utils/path.js';
+import { createMarkdownSkill } from '../../storage/markdown.js';
+import { createSQLiteStorage } from '../../storage/sqlite.js';
+import { createJournalStore } from '../../storage/ndjson.js';
+import type { ProjectSkillShadow, ShadowStatus, OriginSkill } from '../../types/index.js';
+
+const logger = createChildLogger('shadow-registry');
+
+/**
+ * Shadow Skill 注册表
+ * 负责管理项目中的 shadow skills
+ */
+export class ShadowRegistry {
+  private db;
+  private projectRoot: string;
+
+  constructor(projectRoot: string) {
+    this.projectRoot = projectRoot;
+    const dbPath = join(projectRoot, '.evo', 'state', 'sessions.db');
+    this.db = createSQLiteStorage(dbPath);
+  }
+
+  /**
+   * 初始化数据库
+   */
+  async init(): Promise<void> {
+    await this.db.init();
+  }
+
+  /**
+   * 获取项目的 shadow skill
+   */
+  async get(skillId: string): Promise<ProjectSkillShadow | null> {
+    return this.db.getShadowSkill(this.projectRoot, skillId);
+  }
+
+  /**
+   * 列出项目的所有 shadow skills
+   */
+  async list(): Promise<ProjectSkillShadow[]> {
+    return this.db.listShadowSkills(this.projectRoot);
+  }
+
+  /**
+   * 从 origin 创建 shadow
+   */
+  async fork(origin: OriginSkill): Promise<ProjectSkillShadow> {
+    const shadowId = `${origin.skill_id}@${this.getProjectId()}`;
+    const now = new Date().toISOString();
+
+    // 创建 shadow 目录结构
+    const shadowDir = join(this.projectRoot, '.evo', 'skills', origin.skill_id);
+    const snapshotsDir = join(shadowDir, 'snapshots');
+
+    if (!existsSync(shadowDir)) {
+      mkdirSync(shadowDir, { recursive: true });
+    }
+    if (!existsSync(snapshotsDir)) {
+      mkdirSync(snapshotsDir, { recursive: true });
+    }
+
+    // 复制 origin 内容到 shadow
+    const shadowPath = getShadowSkillPath(this.projectRoot, origin.skill_id);
+    const shadowSkill = createMarkdownSkill(shadowPath);
+    shadowSkill.copyFromOrigin(origin.origin_path);
+
+    // 创建 meta.json
+    const metaPath = getShadowMetaPath(this.projectRoot, origin.skill_id);
+    const meta: ProjectSkillShadow = {
+      shadow_id: shadowId,
+      project_id: this.projectRoot,
+      skill_id: origin.skill_id,
+      origin_skill_id: origin.skill_id,
+      origin_version_at_fork: origin.origin_version,
+      shadow_path: shadowPath,
+      current_revision: 0,
+      status: 'active' as ShadowStatus,
+      created_at: now,
+      last_optimized_at: '',
+    };
+    writeFileSync(metaPath, JSON.stringify(meta, null, 2), 'utf-8');
+
+    // 保存到数据库
+    this.db.upsertShadowSkill(meta);
+
+    logger.info(`Shadow skill created: ${shadowId}`, {
+      origin: origin.skill_id,
+      path: shadowPath,
+    });
+
+    return meta;
+  }
+
+  /**
+   * 检查 shadow 是否存在
+   */
+  async exists(skillId: string): Promise<boolean> {
+    const shadow = await this.get(skillId);
+    return shadow !== null;
+  }
+
+  /**
+   * 更新 shadow 状态
+   */
+  async updateStatus(shadowId: string, status: ShadowStatus): Promise<void> {
+    this.db.updateShadowStatus(shadowId, status);
+  }
+
+  /**
+   * 更新 shadow revision
+   */
+  async updateRevision(shadowId: string, revision: number): Promise<void> {
+    this.db.updateShadowRevision(shadowId, revision);
+  }
+
+  /**
+   * 读取 shadow skill 内容
+   */
+  async readContent(skillId: string): Promise<string | null> {
+    const shadowPath = getShadowSkillPath(this.projectRoot, skillId);
+    if (!existsSync(shadowPath)) {
+      return null;
+    }
+
+    try {
+      const shadowSkill = createMarkdownSkill(shadowPath);
+      return shadowSkill.read();
+    } catch (error) {
+      logger.warn(`Failed to read shadow content: ${skillId}`, { error });
+      return null;
+    }
+  }
+
+  /**
+   * 写入 shadow skill 内容
+   */
+  async writeContent(skillId: string, content: string): Promise<void> {
+    const shadowPath = getShadowSkillPath(this.projectRoot, skillId);
+    const shadowSkill = createMarkdownSkill(shadowPath);
+    shadowSkill.write(content);
+  }
+
+  /**
+   * 获取 shadow 的 journal
+   */
+  getJournal(skillId: string) {
+    const journalPath = getShadowJournalPath(this.projectRoot, skillId);
+    return createJournalStore(journalPath);
+  }
+
+  /**
+   * 获取 shadow 的 snapshots 目录
+   */
+  getSnapshotsDir(skillId: string): string {
+    return getSnapshotsDir(this.projectRoot, skillId);
+  }
+
+  /**
+   * 获取项目 ID（使用项目根目录的哈希）
+   */
+  private getProjectId(): string {
+    const { shortHash } = require('../../utils/hash.js');
+    return shortHash(this.projectRoot);
+  }
+
+  /**
+   * 确保项目 .evo 目录结构存在
+   */
+  async ensureProjectStructure(): Promise<void> {
+    const evoDir = join(this.projectRoot, '.evo');
+    const dirs = [
+      join(evoDir, 'skills'),
+      join(evoDir, 'state'),
+      join(evoDir, 'config'),
+    ];
+
+    for (const dir of dirs) {
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+    }
+
+    logger.debug('Project structure ensured', { projectRoot: this.projectRoot });
+  }
+
+  /**
+   * 关闭数据库连接
+   */
+  close(): void {
+    this.db.close();
+  }
+}
+
+// 导出工厂函数
+export function createShadowRegistry(projectRoot: string): ShadowRegistry {
+  return new ShadowRegistry(projectRoot);
+}

package/src/daemon/index.ts

@@ -0,0 +1,174 @@
+import { watch, type FSWatcher } from 'chokidar';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { createChildLogger } from '../utils/logger.js';
+import { createShadowManager } from '../core/shadow-manager/index.js';
+import { createCodexObserver } from '../core/observer/codex-observer.js';
+
+const logger = createChildLogger('daemon');
+
+/**
+ * 后台守护进程
+ * 负责监听文件变化和定时任务
+ */
+export class Daemon {
+  private projectRoot: string;
+  private shadowManager;
+  private codexObserver;
+  private watcher: FSWatcher | null = null;
+  private isRunning: boolean = false;
+  private cleanupInterval: NodeJS.Timeout | null = null;
+
+  constructor(projectRoot: string) {
+    this.projectRoot = projectRoot;
+    this.shadowManager = createShadowManager(projectRoot);
+    this.codexObserver = createCodexObserver();
+  }
+
+  /**
+   * 启动守护进程
+   */
+  async start(): Promise<void> {
+    if (this.isRunning) {
+      logger.warn('Daemon already running');
+      return;
+    }
+
+    this.isRunning = true;
+    logger.info('Starting daemon', { projectRoot: this.projectRoot });
+
+    // 初始化 shadow manager
+    await this.shadowManager.init();
+
+    // 设置 trace 回调
+    this.codexObserver.onTrace((trace) => {
+      this.shadowManager.processTrace(trace).catch((error) => {
+        logger.error('Failed to process trace', { error });
+      });
+    });
+
+    // 启动 codex observer
+    await this.codexObserver.start();
+
+    // 监听项目 .sea 目录变化
+    this.startFileWatcher();
+
+    // 启动定时清理任务
+    this.startCleanupTask();
+
+    logger.info('Daemon started successfully');
+  }
+
+  /**
+   * 启动文件监听器
+   */
+  private startFileWatcher(): void {
+    const seaDir = join(this.projectRoot, '.sea');
+
+    if (!existsSync(seaDir)) {
+      logger.debug('.sea directory not found, skipping file watcher');
+      return;
+    }
+
+    this.watcher = watch(seaDir, {
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 200,
+        pollInterval: 100,
+      },
+    });
+
+    this.watcher.on('change', (path) => {
+      logger.debug('File changed', { path });
+      // 可以在这里处理文件变化
+    });
+
+    this.watcher.on('error', (error) => {
+      logger.error('File watcher error', { error });
+    });
+
+    logger.info('File watcher started', { path: seaDir });
+  }
+
+  /**
+   * 启动定时清理任务
+   */
+  private startCleanupTask(): void {
+    // 每小时清理一次旧 traces
+    this.cleanupInterval = setInterval(
+      async () => {
+        try {
+          const retentionDays = 30;
+          const cleaned = await this.shadowManager.cleanupOldTraces(retentionDays);
+          if (cleaned > 0) {
+            logger.info(`Cleaned ${cleaned} old traces`);
+          }
+        } catch (error) {
+          logger.error('Cleanup task failed', { error });
+        }
+      },
+      60 * 60 * 1000 // 1 小时
+    );
+
+    logger.info('Cleanup task started');
+  }
+
+  /**
+   * 停止守护进程
+   */
+  async stop(): Promise<void> {
+    if (!this.isRunning) {
+      return;
+    }
+
+    this.isRunning = false;
+    logger.info('Stopping daemon');
+
+    // 停止 codex observer
+    await this.codexObserver.stop();
+
+    // 停止文件监听器
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+
+    // 停止定时任务
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+
+    // 关闭 shadow manager
+    this.shadowManager.close();
+
+    logger.info('Daemon stopped');
+  }
+
+  /**
+   * 检查是否正在运行
+   */
+  isActive(): boolean {
+    return this.isRunning;
+  }
+
+  /**
+   * 获取 shadow manager
+   */
+  getShadowManager() {
+    return this.shadowManager;
+  }
+
+  /**
+   * 获取 codex observer
+   */
+  getCodexObserver() {
+    return this.codexObserver;
+  }
+}
+
+// 导出工厂函数
+export function createDaemon(projectRoot: string): Daemon {
+  return new Daemon(projectRoot);
+}

package/src/storage/index.ts

@@ -0,0 +1,7 @@
+/**
+ * 存储层入口
+ */
+
+export { SQLiteStorage, createSQLiteStorage } from './sqlite.js';
+export { NDJSONReader, NDJSONWriter, TraceStore, JournalStore, createTraceStore, createJournalStore } from './ndjson.js';
+export { MarkdownSkill, createMarkdownSkill } from './markdown.js';