evo-skills 0.1.0

package/src/core/journal/index.ts

@@ -0,0 +1,286 @@
+import { existsSync, mkdirSync, copyFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createChildLogger } from '../../utils/logger.js';
+import { hashString } from '../../utils/hash.js';
+import { createJournalStore } from '../../storage/ndjson.js';
+import { createSQLiteStorage } from '../../storage/sqlite.js';
+import type { EvolutionRecord, JournalQueryOptions } from '../../types/index.js';
+
+const logger = createChildLogger('journal');
+
+/**
+ * Journal Manager
+ * 负责管理演化日志和版本控制
+ */
+export class JournalManager {
+  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();
+  }
+
+  /**
+   * 记录一次演化
+   */
+  async record(
+    shadowId: string,
+    record: Omit<EvolutionRecord, 'revision'>
+  ): Promise<number> {
+    // 获取当前 revision
+    const currentRevision = await this.getLatestRevision(shadowId);
+    const newRevision = currentRevision + 1;
+
+    // 创建完整的演化记录
+    const fullRecord: EvolutionRecord = {
+      ...record,
+      revision: newRevision,
+    };
+
+    // 写入 journal
+    const journal = this.getJournal(shadowId);
+    journal.append(fullRecord);
+
+    // 更新数据库索引
+    this.db.addEvolutionRecordIndex({
+      shadow_id: shadowId,
+      revision: newRevision,
+      timestamp: fullRecord.timestamp,
+      change_type: fullRecord.change_type,
+      source_sessions: fullRecord.source_sessions,
+      confidence: 0, // 默认置信度
+    });
+
+    // 更新 shadow revision
+    const skillId = this.extractSkillId(shadowId);
+    if (skillId) {
+      this.db.updateShadowRevision(shadowId, newRevision);
+    }
+
+    logger.info(`Evolution recorded: revision ${newRevision}`, {
+      shadow_id: shadowId,
+      change_type: fullRecord.change_type,
+    });
+
+    return newRevision;
+  }
+
+  /**
+   * 获取 journal
+   */
+  getJournal(shadowId: string) {
+    const skillId = this.extractSkillId(shadowId);
+    const journalPath = join(
+      this.projectRoot,
+      '.evo',
+      'skills',
+      skillId,
+      'journal.ndjson'
+    );
+    return createJournalStore(journalPath);
+  }
+
+  /**
+   * 获取 journal 记录
+   */
+  async getJournalRecords(
+    shadowId: string,
+    options?: JournalQueryOptions
+  ): Promise<EvolutionRecord[]> {
+    const journal = this.getJournal(shadowId);
+    const allRecords = await journal.readAll();
+
+    let filtered = allRecords;
+
+    if (options?.fromRevision !== undefined) {
+      filtered = filtered.filter((r) => r.revision >= options.fromRevision!);
+    }
+
+    if (options?.toRevision !== undefined) {
+      filtered = filtered.filter((r) => r.revision <= options.toRevision!);
+    }
+
+    if (options?.changeType) {
+      filtered = filtered.filter((r) => r.change_type === options.changeType);
+    }
+
+    // 按 revision 降序排列
+    filtered.sort((a, b) => b.revision - a.revision);
+
+    if (options?.limit) {
+      filtered = filtered.slice(0, options.limit);
+    }
+
+    return filtered;
+  }
+
+  /**
+   * 获取最新 revision
+   */
+  async getLatestRevision(shadowId: string): Promise<number> {
+    const journal = this.getJournal(shadowId);
+    return journal.getLatestRevision();
+  }
+
+  /**
+   * 获取指定 revision 的记录
+   */
+  async getRecordByRevision(
+    shadowId: string,
+    revision: number
+  ): Promise<EvolutionRecord | null> {
+    const journal = this.getJournal(shadowId);
+    return journal.getByRevision(revision);
+  }
+
+  /**
+   * 创建 snapshot
+   */
+  async createSnapshot(shadowId: string, revision?: number): Promise<void> {
+    const skillId = this.extractSkillId(shadowId);
+    const targetRevision = revision ?? (await this.getLatestRevision(shadowId));
+
+    // 读取当前 shadow 内容
+    const shadowPath = join(
+      this.projectRoot,
+      '.evo',
+      'skills',
+      skillId,
+      'current.md'
+    );
+
+    if (!existsSync(shadowPath)) {
+      throw new Error(`Shadow skill not found: ${skillId}`);
+    }
+
+    // 创建 snapshot 文件
+    const snapshotsDir = join(
+      this.projectRoot,
+      '.evo',
+      'skills',
+      skillId,
+      'snapshots'
+    );
+
+    if (!existsSync(snapshotsDir)) {
+      mkdirSync(snapshotsDir, { recursive: true });
+    }
+
+    const snapshotFileName = `rev_${String(targetRevision).padStart(4, '0')}.md`;
+    const snapshotPath = join(snapshotsDir, snapshotFileName);
+
+    // 复制当前内容到 snapshot
+    copyFileSync(shadowPath, snapshotPath);
+
+    // 计算内容哈希
+    const { readFileSync } = require('node:fs');
+    const content = readFileSync(shadowPath, 'utf-8');
+    const contentHash = hashString(content);
+
+    // 记录到数据库
+    this.db.addSnapshot({
+      shadow_id: shadowId,
+      revision: targetRevision,
+      timestamp: new Date().toISOString(),
+      file_path: snapshotPath,
+      content_hash: contentHash,
+    });
+
+    logger.info(`Snapshot created: revision ${targetRevision}`, {
+      shadow_id: shadowId,
+      path: snapshotPath,
+    });
+  }
+
+  /**
+   * 回滚到指定 revision
+   */
+  async rollback(shadowId: string, targetRevision: number): Promise<void> {
+    const skillId = this.extractSkillId(shadowId);
+
+    // 查找 snapshot
+    const snapshots = this.db.getSnapshots(shadowId);
+    const snapshot = snapshots.find((s) => s.revision === targetRevision);
+
+    if (!snapshot) {
+      throw new Error(`Snapshot not found for revision ${targetRevision}`);
+    }
+
+    // 复制 snapshot 到当前
+    const shadowPath = join(
+      this.projectRoot,
+      '.evo',
+      'skills',
+      skillId,
+      'current.md'
+    );
+
+    copyFileSync(snapshot.file_path, shadowPath);
+
+    // 更新 revision
+    this.db.updateShadowRevision(shadowId, targetRevision);
+
+    logger.info(`Rolled back to revision ${targetRevision}`, {
+      shadow_id: shadowId,
+      snapshot_path: snapshot.file_path,
+    });
+  }
+
+  /**
+   * 回滚到上一个 snapshot
+   */
+  async rollbackToSnapshot(shadowId: string): Promise<void> {
+    const snapshots = this.db.getSnapshots(shadowId);
+    if (snapshots.length === 0) {
+      throw new Error('No snapshots available');
+    }
+
+    // 获取最新的 snapshot
+    const latestSnapshot = snapshots[0];
+    await this.rollback(shadowId, latestSnapshot.revision);
+  }
+
+  /**
+   * 获取所有 snapshots
+   */
+  getSnapshots(shadowId: string) {
+    return this.db.getSnapshots(shadowId);
+  }
+
+  /**
+   * 获取最新 snapshot
+   */
+  getLatestSnapshot(shadowId: string) {
+    return this.db.getLatestSnapshot(shadowId);
+  }
+
+  /**
+   * 从 shadowId 提取 skillId
+   */
+  private extractSkillId(shadowId: string): string {
+    // shadowId 格式: skillId@projectId
+    const parts = shadowId.split('@');
+    return parts[0] || shadowId;
+  }
+
+  /**
+   * 关闭数据库连接
+   */
+  close(): void {
+    this.db.close();
+  }
+}
+
+// 导出工厂函数
+export function createJournalManager(projectRoot: string): JournalManager {
+  return new JournalManager(projectRoot);
+}

package/src/core/observer/base-observer.ts

@@ -0,0 +1,200 @@
+import { createChildLogger } from '../../utils/logger.js';
+import type { Trace, TraceStatus, RuntimeType } from '../../types/index.js';
+import { v4 as uuidv4 } from 'uuid';
+
+const logger = createChildLogger('observer');
+
+/**
+ * Observer 基类
+ * 负责从主 Agent 采集执行 trace
+ */
+export abstract class BaseObserver {
+  protected runtime: RuntimeType;
+  protected isRunning: boolean = false;
+  protected onTraceCallback?: (trace: Trace) => void;
+
+  constructor(runtime: RuntimeType) {
+    this.runtime = runtime;
+  }
+
+  /**
+   * 启动 observer
+   */
+  abstract start(): Promise<void>;
+
+  /**
+   * 停止 observer
+   */
+  abstract stop(): Promise<void>;
+
+  /**
+   * 注册 trace 回调
+   */
+  onTrace(callback: (trace: Trace) => void): void {
+    this.onTraceCallback = callback;
+  }
+
+  /**
+   * 发送 trace
+   */
+  protected emitTrace(trace: Omit<Trace, 'trace_id' | 'runtime'>): void {
+    const fullTrace: Trace = {
+      ...trace,
+      trace_id: uuidv4(),
+      runtime: this.runtime,
+    };
+
+    logger.debug('Trace emitted', {
+      trace_id: fullTrace.trace_id,
+      event_type: fullTrace.event_type,
+    });
+
+    this.onTraceCallback?.(fullTrace);
+  }
+
+  /**
+   * 创建用户输入 trace
+   */
+  protected createUserInputTrace(
+    sessionId: string,
+    turnId: string,
+    input: string
+  ): Omit<Trace, 'trace_id' | 'runtime'> {
+    return {
+      session_id: sessionId,
+      turn_id: turnId,
+      event_type: 'user_input',
+      timestamp: new Date().toISOString(),
+      user_input: input,
+      status: 'success',
+    };
+  }
+
+  /**
+   * 创建助手输出 trace
+   */
+  protected createAssistantOutputTrace(
+    sessionId: string,
+    turnId: string,
+    output: string
+  ): Omit<Trace, 'trace_id' | 'runtime'> {
+    return {
+      session_id: sessionId,
+      turn_id: turnId,
+      event_type: 'assistant_output',
+      timestamp: new Date().toISOString(),
+      assistant_output: output,
+      status: 'success',
+    };
+  }
+
+  /**
+   * 创建工具调用 trace
+   */
+  protected createToolCallTrace(
+    sessionId: string,
+    turnId: string,
+    toolName: string,
+    toolArgs: Record<string, unknown>
+  ): Omit<Trace, 'trace_id' | 'runtime'> {
+    return {
+      session_id: sessionId,
+      turn_id: turnId,
+      event_type: 'tool_call',
+      timestamp: new Date().toISOString(),
+      tool_name: toolName,
+      tool_args: toolArgs,
+      status: 'success',
+    };
+  }
+
+  /**
+   * 创建工具结果 trace
+   */
+  protected createToolResultTrace(
+    sessionId: string,
+    turnId: string,
+    toolName: string,
+    toolResult: Record<string, unknown>,
+    status: TraceStatus = 'success'
+  ): Omit<Trace, 'trace_id' | 'runtime'> {
+    return {
+      session_id: sessionId,
+      turn_id: turnId,
+      event_type: 'tool_result',
+      timestamp: new Date().toISOString(),
+      tool_name: toolName,
+      tool_result: toolResult,
+      status,
+    };
+  }
+
+  /**
+   * 创建文件变化 trace
+   */
+  protected createFileChangeTrace(
+    sessionId: string,
+    turnId: string,
+    filesChanged: string[]
+  ): Omit<Trace, 'trace_id' | 'runtime'> {
+    return {
+      session_id: sessionId,
+      turn_id: turnId,
+      event_type: 'file_change',
+      timestamp: new Date().toISOString(),
+      files_changed: filesChanged,
+      status: 'success',
+    };
+  }
+
+  /**
+   * 创建重试 trace
+   */
+  protected createRetryTrace(
+    sessionId: string,
+    turnId: string,
+    reason?: string
+  ): Omit<Trace, 'trace_id' | 'runtime'> {
+    return {
+      session_id: sessionId,
+      turn_id: turnId,
+      event_type: 'retry',
+      timestamp: new Date().toISOString(),
+      status: 'retry',
+      metadata: reason ? { reason } : undefined,
+    };
+  }
+
+  /**
+   * 创建状态 trace
+   */
+  protected createStatusTrace(
+    sessionId: string,
+    turnId: string,
+    status: TraceStatus,
+    metadata?: Record<string, unknown>
+  ): Omit<Trace, 'trace_id' | 'runtime'> {
+    return {
+      session_id: sessionId,
+      turn_id: turnId,
+      event_type: 'status',
+      timestamp: new Date().toISOString(),
+      status,
+      metadata,
+    };
+  }
+
+  /**
+   * 检查是否正在运行
+   */
+  isActive(): boolean {
+    return this.isRunning;
+  }
+
+  /**
+   * 获取 runtime 类型
+   */
+  getRuntime(): RuntimeType {
+    return this.runtime;
+  }
+}