@winspan/claude-forge 8.41.0 → 8.51.0

package/tests/e2e/dashboard.spec.ts

@@ -0,0 +1,205 @@
+/**
+ * E2E 测试：管理后台 Dashboard
+ *
+ * 运行前提：
+ * 1. 安装 Playwright: npm install -D @playwright/test
+ * 2. 启动守护进程: claude-forge daemon start
+ * 3. 运行测试: npm run test:e2e
+ */
+
+import { test, expect } from '@playwright/test';
+
+const BASE_URL = 'http://localhost:3721';
+
+test.describe('Dashboard 页面', () => {
+  test('应该正确加载并显示统计卡片', async ({ page }) => {
+    await page.goto(BASE_URL);
+
+    // 等待页面加载
+    await page.waitForSelector('#dash-stats');
+
+    // 检查统计卡片是否存在
+    await expect(page.locator('.stat-card')).toHaveCount(4);
+
+    // 检查守护进程状态
+    const status = await page.locator('#daemon-status').textContent();
+    expect(['运行中', '离线', '检查中']).toContain(status);
+  });
+
+  test('应该显示近 7 天活动图表', async ({ page }) => {
+    await page.goto(BASE_URL);
+
+    // 检查图表容器
+    await expect(page.locator('#chart-activity')).toBeVisible();
+    await expect(page.locator('#chart-tools')).toBeVisible();
+  });
+
+  test('应该显示最近会话列表', async ({ page }) => {
+    await page.goto(BASE_URL);
+
+    // 检查会话列表容器
+    await expect(page.locator('#dash-sessions')).toBeVisible();
+  });
+});
+
+test.describe('Sessions 页面', () => {
+  test('应该正确加载会话列表', async ({ page }) => {
+    await page.goto(BASE_URL);
+
+    // 点击 Sessions 导航
+    await page.click('#nav-sessions');
+
+    // 等待页面切换
+    await page.waitForSelector('#page-sessions.active');
+
+    // 检查搜索框
+    await expect(page.locator('#sessions-search')).toBeVisible();
+
+    // 检查列表容器
+    await expect(page.locator('#sessions-list')).toBeVisible();
+  });
+
+  test('搜索功能应该正常工作', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-sessions');
+    await page.waitForSelector('#page-sessions.active');
+
+    // 输入搜索关键词
+    await page.fill('#sessions-search', 'test');
+
+    // 等待搜索结果更新（通过 oninput 触发）
+    await page.waitForTimeout(300);
+
+    // 验证搜索框有值
+    const searchValue = await page.inputValue('#sessions-search');
+    expect(searchValue).toBe('test');
+  });
+
+  test('点击会话应该打开详情抽屉', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-sessions');
+    await page.waitForSelector('#page-sessions.active');
+
+    // 等待会话列表加载
+    await page.waitForTimeout(500);
+
+    // 如果有会话，点击第一个
+    const firstSession = page.locator('.list-item').first();
+    if (await firstSession.isVisible()) {
+      await firstSession.click();
+
+      // 检查抽屉是否打开
+      await expect(page.locator('#drawer.open')).toBeVisible();
+      await expect(page.locator('#drawer-title')).toContainText('会话');
+    }
+  });
+});
+
+test.describe('Events 页面', () => {
+  test('应该正确加载事件列表', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-events');
+    await page.waitForSelector('#page-events.active');
+
+    // 检查搜索框和筛选器
+    await expect(page.locator('#events-search')).toBeVisible();
+    await expect(page.locator('#events-type')).toBeVisible();
+
+    // 检查表格
+    await expect(page.locator('#events-body')).toBeVisible();
+  });
+
+  test('类型筛选应该正常工作', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-events');
+    await page.waitForSelector('#page-events.active');
+
+    // 选择筛选类型
+    await page.selectOption('#events-type', 'PreToolUse');
+
+    // 等待筛选结果更新
+    await page.waitForTimeout(300);
+
+    // 验证筛选器有值
+    const selectedValue = await page.inputValue('#events-type');
+    expect(selectedValue).toBe('PreToolUse');
+  });
+});
+
+test.describe('Injections 页面', () => {
+  test('应该正确加载注入列表', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-injections');
+    await page.waitForSelector('#page-injections.active');
+
+    // 检查搜索框和筛选器
+    await expect(page.locator('#inj-search')).toBeVisible();
+    await expect(page.locator('#inj-handler')).toBeVisible();
+
+    // 检查列表容器
+    await expect(page.locator('#inj-list')).toBeVisible();
+  });
+});
+
+test.describe('Rules 页面', () => {
+  test('应该正确加载规则列表', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-rules');
+    await page.waitForSelector('#page-rules.active');
+
+    // 检查搜索框
+    await expect(page.locator('#rules-search')).toBeVisible();
+
+    // 检查列表容器
+    await expect(page.locator('#rules-list')).toBeVisible();
+  });
+});
+
+test.describe('Live 页面', () => {
+  test('应该正确加载实时监控页面', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-live');
+    await page.waitForSelector('#page-live.active');
+
+    // 检查状态和按钮
+    await expect(page.locator('#live-status')).toBeVisible();
+    await expect(page.locator('#live-btn')).toBeVisible();
+
+    // 检查日志容器
+    await expect(page.locator('#live-log')).toBeVisible();
+  });
+});
+
+test.describe('导航功能', () => {
+  test('所有导航链接应该正常工作', async ({ page }) => {
+    await page.goto(BASE_URL);
+
+    const navItems = [
+      { id: 'nav-dashboard', pageId: 'page-dashboard' },
+      { id: 'nav-sessions', pageId: 'page-sessions' },
+      { id: 'nav-events', pageId: 'page-events' },
+      { id: 'nav-injections', pageId: 'page-injections' },
+      { id: 'nav-live', pageId: 'page-live' },
+      { id: 'nav-rules', pageId: 'page-rules' }
+    ];
+
+    for (const item of navItems) {
+      await page.click(`#${item.id}`);
+      await page.waitForSelector(`#${item.pageId}.active`);
+      await expect(page.locator(`#${item.pageId}`)).toHaveClass(/active/);
+    }
+  });
+
+  test('刷新按钮应该正常工作', async ({ page }) => {
+    await page.goto(BASE_URL);
+
+    // 点击刷新按钮
+    await page.click('button:has-text("刷新")');
+
+    // 等待页面重新加载
+    await page.waitForTimeout(500);
+
+    // 验证页面仍然可见
+    await expect(page.locator('#dash-stats')).toBeVisible();
+  });
+});

package/tests/e2e/routing-skill-e2e.test.ts

@@ -0,0 +1,39 @@
+/**
+ * E2E Test Suite: Routing & Skill Invocation Verification
+ *
+ * Tests the complete chain:
+ *   1. UserPrompt → Classifier → AgentRouter → routing_events
+ *   2. Agent execution → skill_invoke MCP call → skill_invocations
+ *   3. Data integrity: obeyed tracking, route_request_id linkage
+ *
+ * Prerequisites:
+ *   - Daemon must be running (claude-forge daemon start)
+ *   - Database at ~/.claude-forge/data.db
+ *   - MCP server mounted at http://127.0.0.1:3721/mcp
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { FORGE_PATHS } from '../../src/core/constants.js';
+import { SQLiteStorage } from '../../src/core/storage/sqlite.js';
+
+const DAEMON_TOKEN_PATH = join(FORGE_PATHS.home(), 'daemon.token');
+const DB_PATH = FORGE_PATHS.database();
+
+describe('E2E: Routing & Skill Invocation', () => {
+  let storage: SQLiteStorage;
+  let daemonToken: string;
+
+  beforeAll(() => {
+    // Read daemon token for MCP auth
+    try {
+      daemonToken = readFileSync(DAEMON_TOKEN_PATH, 'utf-8').trim();
+    } catch (err) {
+      throw new Error(
+        `Cannot read daemon token at ${DAEMON_TOKEN_PATH}. ` +
+        `Is the daemon running? Run: claude-forge daemon start`
+      );
+    }
+
+    // Connect to live database

package/tests/helpers/mock-ai.ts

@@ -0,0 +1,92 @@
+import type { AIProvider } from '../../src/core/ai/provider.js';
+
+/**
+ * Mock AI Provider for testing
+ */
+export class MockAIProvider implements AIProvider {
+  private responses: string[] = [];
+  private currentIndex = 0;
+  public callHistory: Array<{ prompt: string; options?: Record<string, unknown> }> = [];
+
+  constructor(responses: string[] = ['mock response']) {
+    this.responses = responses;
+  }
+
+  async complete(prompt: string, options?: { maxTokens?: number; temperature?: number }): Promise<string> {
+    this.callHistory.push({ prompt, options });
+
+    if (this.currentIndex >= this.responses.length) {
+      return this.responses[this.responses.length - 1] || 'default mock response';
+    }
+
+    const response = this.responses[this.currentIndex];
+    this.currentIndex++;
+    return response;
+  }
+
+  /**
+   * Add more responses to the queue
+   */
+  addResponse(response: string): void {
+    this.responses.push(response);
+  }
+
+  /**
+   * Reset the provider state
+   */
+  reset(): void {
+    this.currentIndex = 0;
+    this.callHistory = [];
+  }
+
+  /**
+   * Get the number of times complete() was called
+   */
+  getCallCount(): number {
+    return this.callHistory.length;
+  }
+
+  /**
+   * Get the last prompt sent to complete()
+   */
+  getLastPrompt(): string | undefined {
+    return this.callHistory[this.callHistory.length - 1]?.prompt;
+  }
+}
+
+/**
+ * Create a mock AI provider that always returns the same response
+ */
+export function createMockAI(response: string = 'mock response'): MockAIProvider {
+  return new MockAIProvider([response]);
+}
+
+/**
+ * Create a mock AI provider with multiple responses (returns them in sequence)
+ */
+export function createMockAIWithResponses(responses: string[]): MockAIProvider {
+  return new MockAIProvider(responses);
+}
+
+/**
+ * Create a mock AI provider that throws an error
+ */
+export function createFailingMockAI(errorMessage: string = 'Mock AI error'): AIProvider {
+  return {
+    async complete(): Promise<string> {
+      throw new Error(errorMessage);
+    },
+  };
+}
+
+/**
+ * Create a mock AI provider that simulates slow responses
+ */
+export function createSlowMockAI(response: string = 'slow response', delayMs: number = 100): AIProvider {
+  return {
+    async complete(): Promise<string> {
+      await new Promise(resolve => setTimeout(resolve, delayMs));
+      return response;
+    },
+  };
+}

package/tests/helpers/mock-storage.ts

@@ -0,0 +1,159 @@
+import Database from 'better-sqlite3';
+import type { ForgeEvent } from '../../src/core/types.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+
+/**
+ * Create a temporary in-memory SQLite database for testing
+ */
+export function createMockDatabase(): Database.Database {
+  const db = new Database(':memory:');
+
+  // Create minimal schema
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      event_id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      project_path TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      hook_type TEXT NOT NULL,
+      tool_name TEXT,
+      tool_input TEXT,
+      tool_output TEXT,
+      user_prompt TEXT,
+      ai_response TEXT,
+      distilled INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      session_id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      first_prompt TEXT,
+      start_time TEXT NOT NULL,
+      end_time TEXT,
+      last_event_time TEXT,
+      event_count INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS routing_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      route_request_id TEXT,
+      project_path TEXT NOT NULL,
+      ts INTEGER NOT NULL,
+      prompt TEXT NOT NULL,
+      intent_json TEXT NOT NULL,
+      routed_to_type TEXT,
+      routed_to_name TEXT,
+      is_forced INTEGER DEFAULT 0,
+      obeyed INTEGER,
+      classification_ms INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS injections (
+      id TEXT PRIMARY KEY,
+      event_id TEXT,
+      session_id TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      source_handler TEXT NOT NULL,
+      injection_type TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX idx_events_session ON events(session_id);
+    CREATE INDEX idx_events_timestamp ON events(timestamp DESC);
+    CREATE INDEX idx_sessions_project ON sessions(project_path);
+    CREATE INDEX idx_routing_events_session ON routing_events(session_id);
+    CREATE INDEX idx_injections_session ON injections(session_id);
+  `);
+
+  return db;
+}
+
+/**
+ * Create a temporary file-based database for testing
+ */
+export function createTempDatabase(): { db: Database.Database; path: string; cleanup: () => void } {
+  const dbPath = path.join(tmpdir(), `test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+  const db = createMockDatabase();
+
+  const cleanup = () => {
+    try {
+      db.close();
+      if (fs.existsSync(dbPath)) {
+        fs.unlinkSync(dbPath);
+      }
+    } catch (err) {
+      // Ignore cleanup errors
+    }
+  };
+
+  return { db, path: dbPath, cleanup };
+}
+
+/**
+ * Create mock ForgeEvent for testing
+ */
+export function createMockEvent(overrides?: Partial<ForgeEvent>): ForgeEvent {
+  return {
+    event_id: `event-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    session_id: 'test-session',
+    project_path: '/test/project',
+    timestamp: new Date().toISOString(),
+    hook_type: 'UserPromptSubmit',
+    user_prompt: 'test prompt',
+    ...overrides,
+  };
+}
+
+/**
+ * Insert mock events into database
+ */
+export function insertMockEvents(db: Database.Database, events: ForgeEvent[]): void {
+  const stmt = db.prepare(`
+    INSERT INTO events (event_id, session_id, project_path, timestamp, hook_type,
+                        tool_name, tool_input, tool_output, user_prompt, ai_response, distilled)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+  `);
+
+  for (const event of events) {
+    stmt.run(
+      event.event_id || `event-${Date.now()}`,
+      event.session_id,
+      event.project_path,
+      event.timestamp,
+      event.hook_type,
+      event.tool_name ?? null,
+      event.tool_input ? JSON.stringify(event.tool_input) : null,
+      event.tool_output ? JSON.stringify(event.tool_output) : null,
+      event.user_prompt ?? null,
+      event.ai_response ?? null,
+    );
+  }
+}
+
+/**
+ * Query all events from database
+ */
+export function queryAllEvents(db: Database.Database): ForgeEvent[] {
+  const rows = db.prepare('SELECT * FROM events ORDER BY timestamp DESC').all() as Array<Record<string, unknown>>;
+
+  return rows.map(row => ({
+    event_id: row.event_id as string,
+    session_id: row.session_id as string,
+    project_path: row.project_path as string,
+    timestamp: row.timestamp as string,
+    hook_type: row.hook_type as ForgeEvent['hook_type'],
+    tool_name: (row.tool_name as string) || undefined,
+    tool_input: row.tool_input ? JSON.parse(row.tool_input as string) : undefined,
+    tool_output: row.tool_output ? JSON.parse(row.tool_output as string) : undefined,
+    user_prompt: (row.user_prompt as string) || undefined,
+    ai_response: (row.ai_response as string) || undefined,
+  }));
+}

package/tests/integration/claudemd-generator.test.ts

@@ -0,0 +1,90 @@
+/**
+ * Integration test for ClaudeMdGenerator — safety-net for L1 SWARM_PROTOCOL extraction.
+ *
+ * Anchors the SWARM section content (open → projectContent boundary) via SHA256
+ * so that the .md file extraction must produce byte-for-byte identical output.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { ClaudeMdGenerator } from '../../src/claudemd/claudemd-generator.js';
+
+// SWARM section SHA256, captured against the literal-string implementation
+// before extracting to swarm-protocol.md. After extraction, this MUST stay equal.
+const SWARM_SECTION_SHA256 =
+  '260dfe1e48fdecc324419a6330428eaa3597e3fd6e6262cf66cdcf301ca32e18';
+
+/**
+ * Minimal stub for ClaudeProvider — only `complete` is exercised by generate().
+ */
+function makeFailingAi(): any {
+  return {
+    complete: async () => {
+      throw new Error('forced AI failure (safety-net)');
+    },
+  };
+}
+
+describe('ClaudeMdGenerator (safety-net)', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'claudemd-gen-'));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('generates fallback CLAUDE.md containing all SWARM_PROTOCOL anchors', async () => {
+    const gen = new ClaudeMdGenerator(makeFailingAi());
+    const output = await gen.generate(tmpDir);
+
+    // ── Key field anchors (SWARM section) ──────────────────────────────
+    expect(output).toContain('# claude-forge 工作区规范');
+    expect(output).toContain('## 自检');
+    expect(output).toContain('Two-Phase Workflow');
+    expect(output).toContain('harness-hotfix');
+    expect(output).toContain('refactor-safe');
+    expect(output).toContain('hybrid-feature-with-safety');
+
+    // ── Total line count ≥ 200 (SWARM ~223 lines + fallback) ───────────
+    const lineCount = output.split('\n').length;
+    expect(lineCount).toBeGreaterThanOrEqual(200);
+  });
+
+  it('SWARM section hash is stable across literal/file-loaded implementations', async () => {
+    const gen = new ClaudeMdGenerator(makeFailingAi());
+    const output = await gen.generate(tmpDir);
+
+    // Split SWARM from projectContent: fallback always starts with sectionOverview ("## 项目概述").
+    // SWARM_PROTOCOL ends with "\n" + "\n\n" separator, so the boundary is the first
+    // "\n\n## 项目概述" occurrence — everything before that is the SWARM section.
+    const boundary = output.indexOf('\n\n## 项目概述');
+    expect(boundary).toBeGreaterThan(0);
+
+    // Include the trailing newline of SWARM_PROTOCOL (it ends with `\n`), exclude the `\n\n` separator.
+    const swarmSection = output.slice(0, boundary + 1);
+
+    const hash = createHash('sha256').update(swarmSection, 'utf-8').digest('hex');
+
+    // Print for first-run baseline capture (visible with --reporter=verbose).
+    // eslint-disable-next-line no-console
+    console.log('[safety-net] SWARM_SECTION_SHA256 =', hash);
+    // eslint-disable-next-line no-console
+    console.log('[safety-net] SWARM section length =', swarmSection.length, 'bytes');
+
+    // Sanity: SWARM section must be substantial.
+    expect(swarmSection.length).toBeGreaterThan(4000);
+    expect(swarmSection.startsWith('# claude-forge 工作区规范')).toBe(true);
+    expect(swarmSection.endsWith('（由 daemon 自动更新，记录最近任务上下文）\n\n')).toBe(true);
+
+    // If a known hash is set (non-placeholder), assert equality.
+    // The placeholder below is the all-zero-ish string used on first run; replaced
+    // automatically by the orchestration script once baseline is captured.
+    expect(hash).toBe(SWARM_SECTION_SHA256);
+  });
+});