evo-skills 0.1.0

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

@@ -0,0 +1,309 @@
+import { watch, type FSWatcher } from 'chokidar';
+import { createReadStream, existsSync, readFileSync, statSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { createInterface } from 'node:readline';
+import { BaseObserver } from './base-observer.js';
+import { createChildLogger } from '../../utils/logger.js';
+
+const logger = createChildLogger('codex-observer');
+
+/**
+ * Codex Observer
+ * 监听 Codex 的 JSONL 事件流和 session 日志
+ */
+export class CodexObserver extends BaseObserver {
+  private watcher: FSWatcher | null = null;
+  private sessionDir: string;
+  private currentSessionId: string | null = null;
+  private turnCounter: number = 0;
+  private lastFileSize: Map<string, number> = new Map();
+
+  constructor(sessionDir?: string) {
+    super('codex');
+    this.sessionDir = sessionDir ?? this.getDefaultSessionDir();
+  }
+
+  /**
+   * 获取默认 session 目录
+   */
+  private getDefaultSessionDir(): string {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? '';
+    return join(home, '.codex', 'sessions');
+  }
+
+  /**
+   * 启动 observer
+   */
+  async start(): Promise<void> {
+    if (this.isRunning) {
+      logger.warn('Observer already running');
+      return;
+    }
+
+    if (!existsSync(this.sessionDir)) {
+      logger.warn(`Session directory not found: ${this.sessionDir}`);
+      return;
+    }
+
+    this.isRunning = true;
+    logger.info('Starting Codex observer', { sessionDir: this.sessionDir });
+
+    // 监听 session 目录的变化
+    this.watcher = watch(this.sessionDir, {
+      persistent: true,
+      ignoreInitial: false,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 50,
+      },
+    });
+
+    this.watcher.on('add', (path) => this.handleFileAdd(path));
+    this.watcher.on('change', (path) => this.handleFileChange(path));
+
+    logger.info('Codex observer started');
+  }
+
+  /**
+   * 停止 observer
+   */
+  async stop(): Promise<void> {
+    if (!this.isRunning) {
+      return;
+    }
+
+    this.isRunning = false;
+
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+
+    logger.info('Codex observer stopped');
+  }
+
+  /**
+   * 处理新文件
+   */
+  private handleFileAdd(path: string): void {
+    if (!path.endsWith('.jsonl')) {
+      return;
+    }
+
+    const sessionId = this.extractSessionId(path);
+    this.currentSessionId = sessionId;
+    this.lastFileSize.set(path, 0);
+
+    logger.info(`New session detected: ${sessionId}`, { path });
+
+    // 读取整个文件
+    this.processJsonlFile(path);
+  }
+
+  /**
+   * 处理文件变化
+   */
+  private handleFileChange(path: string): void {
+    if (!path.endsWith('.jsonl')) {
+      return;
+    }
+
+    const lastSize = this.lastFileSize.get(path) ?? 0;
+    const currentSize = this.getFileSize(path);
+
+    if (currentSize > lastSize) {
+      // 只读取新增的部分
+      this.processJsonlFileIncremental(path, lastSize);
+      this.lastFileSize.set(path, currentSize);
+    }
+  }
+
+  /**
+   * 处理 JSONL 文件（全量）
+   */
+  private processJsonlFile(path: string): void {
+    const sessionId = this.extractSessionId(path);
+
+    try {
+      const content = readFileSync(path, 'utf-8');
+      const lines = content.split('\n').filter((line) => line.trim());
+
+      for (const line of lines) {
+        try {
+          const event = JSON.parse(line);
+          this.processEvent(sessionId, event);
+        } catch {
+          // 忽略解析错误
+        }
+      }
+    } catch (error) {
+      logger.warn(`Failed to read JSONL file: ${path}`, { error });
+    }
+  }
+
+  /**
+   * 处理 JSONL 文件（增量）
+   */
+  private processJsonlFileIncremental(path: string, startOffset: number): void {
+    const sessionId = this.extractSessionId(path);
+
+    try {
+      const stream = createReadStream(path, {
+        start: startOffset,
+        encoding: 'utf-8',
+      });
+
+      const rl = createInterface({
+        input: stream,
+        crlfDelay: Infinity,
+      });
+
+      rl.on('line', (line) => {
+        if (line.trim()) {
+          try {
+            const event = JSON.parse(line);
+            this.processEvent(sessionId, event);
+          } catch {
+            // 忽略解析错误
+          }
+        }
+      });
+    } catch (error) {
+      logger.warn(`Failed to read JSONL file incrementally: ${path}`, { error });
+    }
+  }
+
+  /**
+   * 处理单个事件
+   */
+  private processEvent(sessionId: string, event: Record<string, unknown>): void {
+    const turnId = `turn_${++this.turnCounter}`;
+
+    // 根据事件类型创建相应的 trace
+    switch (event.type) {
+      case 'user_input':
+        this.emitTrace(
+          this.createUserInputTrace(sessionId, turnId, event.content as string)
+        );
+        break;
+
+      case 'assistant_output':
+      case 'assistant_message':
+        this.emitTrace(
+          this.createAssistantOutputTrace(sessionId, turnId, event.content as string)
+        );
+        break;
+
+      case 'tool_call':
+        this.emitTrace(
+          this.createToolCallTrace(sessionId, turnId, event.tool as string, (event.args as Record<string, unknown>) ?? {})
+        );
+        break;
+
+      case 'tool_result':
+        this.emitTrace(
+          this.createToolResultTrace(
+            sessionId,
+            turnId,
+            event.tool as string,
+            (event.result as Record<string, unknown>) ?? {},
+            event.status === 'error' ? 'failure' : 'success'
+          )
+        );
+        break;
+
+      case 'file_change':
+      case 'file_write':
+      case 'file_edit':
+        if (event.files) {
+          this.emitTrace(
+            this.createFileChangeTrace(sessionId, turnId, event.files as string[])
+          );
+        }
+        break;
+
+      case 'retry':
+        this.emitTrace(
+          this.createRetryTrace(sessionId, turnId, event.reason as string)
+        );
+        break;
+
+      case 'error':
+        this.emitTrace(
+          this.createStatusTrace(sessionId, turnId, 'failure', {
+            error: event.error,
+          })
+        );
+        break;
+
+      case 'session_start':
+        logger.info(`Session started: ${sessionId}`);
+        break;
+
+      case 'session_end':
+        logger.info(`Session ended: ${sessionId}`);
+        break;
+
+      default:
+        // 忽略未知事件类型
+        break;
+    }
+  }
+
+  /**
+   * 从文件路径提取 session ID
+   */
+  private extractSessionId(path: string): string {
+    const filename = basename(path, '.jsonl');
+    return filename;
+  }
+
+  /**
+   * 获取文件大小
+   */
+  private getFileSize(path: string): number {
+    try {
+      return statSync(path).size;
+    } catch {
+      return 0;
+    }
+  }
+
+  /**
+   * 手动处理一个 session 文件
+   */
+  async processSessionFile(filePath: string): Promise<void> {
+    if (!existsSync(filePath)) {
+      throw new Error(`Session file not found: ${filePath}`);
+    }
+
+    logger.info(`Processing session file: ${filePath}`);
+    this.processJsonlFile(filePath);
+  }
+
+  /**
+   * 获取当前 session ID
+   */
+  getCurrentSessionId(): string | null {
+    return this.currentSessionId;
+  }
+
+  /**
+   * 设置 session 目录
+   */
+  setSessionDir(dir: string): void {
+    this.sessionDir = dir;
+  }
+
+  /**
+   * 获取 session 目录
+   */
+  getSessionDir(): string {
+    return this.sessionDir;
+  }
+}
+
+// 导出工厂函数
+export function createCodexObserver(sessionDir?: string): CodexObserver {
+  return new CodexObserver(sessionDir);
+}

package/src/core/observer/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Observer 模块入口
+ */
+
+export { BaseObserver } from './base-observer.js';
+export { CodexObserver, createCodexObserver } from './codex-observer.js';
+export { TraceManager, createTraceManager } from './trace-manager.js';

package/src/core/observer/trace-manager.ts

@@ -0,0 +1,250 @@
+import { join } from 'node:path';
+import { createChildLogger } from '../../utils/logger.js';
+import { createTraceStore } from '../../storage/ndjson.js';
+import { createSQLiteStorage } from '../../storage/sqlite.js';
+import type { Trace, RuntimeType } from '../../types/index.js';
+
+const logger = createChildLogger('trace-manager');
+
+/**
+ * Trace 存储管理器
+ * 负责存储和查询 trace 数据
+ */
+export class TraceManager {
+  private projectRoot: string;
+  private db;
+  private traceStore;
+  private currentSessionId: string | null = null;
+
+  constructor(projectRoot: string) {
+    this.projectRoot = projectRoot;
+
+    // 初始化数据库
+    const dbPath = join(projectRoot, '.evo', 'state', 'sessions.db');
+    this.db = createSQLiteStorage(dbPath);
+
+    // 初始化 NDJSON trace store
+    const tracesDir = join(projectRoot, '.evo', 'state');
+    this.traceStore = createTraceStore(tracesDir, 'default');
+  }
+
+  /**
+   * 初始化
+   */
+  async init(): Promise<void> {
+    await this.db.init();
+    logger.info('Trace manager initialized');
+  }
+
+  /**
+   * 设置当前 session
+   */
+  setSession(sessionId: string, runtime: RuntimeType, projectId?: string): void {
+    this.currentSessionId = sessionId;
+
+    // 创建 session 记录
+    this.db.createSession({
+      session_id: sessionId,
+      runtime,
+      project_id: projectId ?? null,
+      started_at: new Date().toISOString(),
+      ended_at: null,
+      trace_count: 0,
+    });
+
+    // 更新 trace store 的 session ID
+    const tracesDir = join(this.projectRoot, '.evo', 'state');
+    this.traceStore = createTraceStore(tracesDir, sessionId);
+
+    logger.info(`Session set: ${sessionId}`, { runtime, projectId });
+  }
+
+  /**
+   * 记录 trace
+   */
+  recordTrace(trace: Trace): void {
+    // 保存到 NDJSON
+    this.traceStore.append(trace);
+
+    // 添加索引到数据库
+    this.db.addTraceIndex({
+      trace_id: trace.trace_id,
+      session_id: trace.session_id,
+      runtime: trace.runtime,
+      event_type: trace.event_type,
+      timestamp: trace.timestamp,
+      status: trace.status,
+    });
+
+    // 更新 session trace 计数
+    this.db.incrementSessionTraceCount(trace.session_id);
+
+    logger.debug('Trace recorded', {
+      trace_id: trace.trace_id,
+      event_type: trace.event_type,
+    });
+  }
+
+  /**
+   * 批量记录 traces
+   */
+  recordTraces(traces: Trace[]): void {
+    for (const trace of traces) {
+      this.recordTrace(trace);
+    }
+  }
+
+  /**
+   * 获取 session 的 traces
+   */
+  async getSessionTraces(sessionId: string, limit?: number): Promise<Trace[]> {
+    const allTraces = await this.traceStore.readAll();
+
+    let filtered = allTraces.filter((t) => t.session_id === sessionId);
+
+    // 按时间戳排序
+    filtered.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+
+    if (limit) {
+      filtered = filtered.slice(0, limit);
+    }
+
+    return filtered;
+  }
+
+  /**
+   * 获取最近的 traces
+   */
+  async getRecentTraces(count: number): Promise<Trace[]> {
+    return this.traceStore.readRecent(count);
+  }
+
+  /**
+   * 按事件类型查询 traces
+   */
+  async getTracesByEventType(
+    sessionId: string,
+    eventType: string
+  ): Promise<Trace[]> {
+    const allTraces = await this.traceStore.readAll();
+    return allTraces.filter(
+      (t) => t.session_id === sessionId && t.event_type === eventType
+    );
+  }
+
+  /**
+   * 按时间范围查询 traces
+   */
+  async getTracesByTimeRange(
+    sessionId: string,
+    startTime: string,
+    endTime: string
+  ): Promise<Trace[]> {
+    const allTraces = await this.traceStore.readAll();
+    const start = new Date(startTime).getTime();
+    const end = new Date(endTime).getTime();
+
+    return allTraces.filter((t) => {
+      if (t.session_id !== sessionId) return false;
+      const time = new Date(t.timestamp).getTime();
+      return time >= start && time <= end;
+    });
+  }
+
+  /**
+   * 获取失败的 traces
+   */
+  async getFailedTraces(sessionId: string): Promise<Trace[]> {
+    const allTraces = await this.traceStore.readAll();
+    return allTraces.filter(
+      (t) => t.session_id === sessionId && t.status === 'failure'
+    );
+  }
+
+  /**
+   * 获取重试的 traces
+   */
+  async getRetryTraces(sessionId: string): Promise<Trace[]> {
+    const allTraces = await this.traceStore.readAll();
+    return allTraces.filter(
+      (t) => t.session_id === sessionId && t.event_type === 'retry'
+    );
+  }
+
+  /**
+   * 获取文件变化的 traces
+   */
+  async getFileChangeTraces(sessionId: string): Promise<Trace[]> {
+    const allTraces = await this.traceStore.readAll();
+    return allTraces.filter(
+      (t) => t.session_id === sessionId && t.event_type === 'file_change'
+    );
+  }
+
+  /**
+   * 获取 trace 统计信息
+   */
+  async getTraceStats(sessionId: string): Promise<{
+    total: number;
+    byEventType: Record<string, number>;
+    byStatus: Record<string, number>;
+  }> {
+    const allTraces = await this.traceStore.readAll();
+    const sessionTraces = allTraces.filter((t) => t.session_id === sessionId);
+
+    const byEventType: Record<string, number> = {};
+    const byStatus: Record<string, number> = {};
+
+    for (const trace of sessionTraces) {
+      byEventType[trace.event_type] = (byEventType[trace.event_type] ?? 0) + 1;
+      byStatus[trace.status] = (byStatus[trace.status] ?? 0) + 1;
+    }
+
+    return {
+      total: sessionTraces.length,
+      byEventType,
+      byStatus,
+    };
+  }
+
+  /**
+   * 清理旧的 traces
+   */
+  async cleanupOldTraces(retentionDays: number): Promise<number> {
+    // 这里可以实现清理逻辑
+    // 暂时返回 0
+    logger.info(`Cleanup old traces older than ${retentionDays} days`);
+    return 0;
+  }
+
+  /**
+   * 获取当前 session ID
+   */
+  getCurrentSessionId(): string | null {
+    return this.currentSessionId;
+  }
+
+  /**
+   * 结束当前 session
+   */
+  endSession(): void {
+    if (this.currentSessionId) {
+      logger.info(`Session ended: ${this.currentSessionId}`);
+      this.currentSessionId = null;
+    }
+  }
+
+  /**
+   * 关闭
+   */
+  close(): void {
+    this.endSession();
+    this.db.close();
+    logger.info('Trace manager closed');
+  }
+}
+
+// 导出工厂函数
+export function createTraceManager(projectRoot: string): TraceManager {
+  return new TraceManager(projectRoot);
+}