@winspan/claude-forge 8.41.0 → 8.51.0

package/tests/unit/skill-invocations-workflow.test.ts

@@ -0,0 +1,495 @@
+/**
+ * skill_invocations 工作流追踪扩展测试
+ *
+ * 覆盖：
+ *   1. parseWorkflowMeta() 各种 reason 输入下的解析行为
+ *   2. writeSkillInvocation 持久化新字段并能被 querySkillInvocations 取回
+ *   3. queryWorkflowProgress 按 route_request_id 聚合 phases / 计数 / 时间戳
+ *   4. 增量迁移：模拟旧库（没有 workflow / phase / feature_slug / artifact_path 列），
+ *      重建 storage 后 runMigrations 应自动补齐列与索引
+ */
+
+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 { randomUUID } from 'node:crypto';
+import Database from 'better-sqlite3';
+import { SQLiteStorage } from '../../src/core/storage/sqlite.js';
+import { parseWorkflowMeta } from '../../src/skills/tools/skill-invoke.js';
+
+describe('parseWorkflowMeta', () => {
+  it('解析 "bmad/analyze" → workflow + phase, feature_slug 为 null', () => {
+    expect(parseWorkflowMeta('bmad/analyze')).toEqual({
+      workflow: 'bmad',
+      phase: 'analyze',
+      feature_slug: null,
+    });
+  });
+
+  it('解析 "bmad/design:login-feature" → 三个字段都有值', () => {
+    expect(parseWorkflowMeta('bmad/design:login-feature')).toEqual({
+      workflow: 'bmad',
+      phase: 'design',
+      feature_slug: 'login-feature',
+    });
+  });
+
+  it('解析 "harness/safety-net" → 支持 phase 中含连字符', () => {
+    expect(parseWorkflowMeta('harness/safety-net')).toEqual({
+      workflow: 'harness',
+      phase: 'safety-net',
+      feature_slug: null,
+    });
+  });
+
+  it('解析普通文本（"plain text"） → 全部为 null', () => {
+    expect(parseWorkflowMeta('plain text')).toEqual({
+      workflow: null,
+      phase: null,
+      feature_slug: null,
+    });
+  });
+
+  it('空字符串 / undefined / null → 全部为 null', () => {
+    expect(parseWorkflowMeta('')).toEqual({ workflow: null, phase: null, feature_slug: null });
+    expect(parseWorkflowMeta(undefined)).toEqual({ workflow: null, phase: null, feature_slug: null });
+    expect(parseWorkflowMeta(null)).toEqual({ workflow: null, phase: null, feature_slug: null });
+  });
+
+  it('大小写归一化：Bmad/Analyze → bmad/analyze', () => {
+    expect(parseWorkflowMeta('Bmad/Analyze')).toEqual({
+      workflow: 'bmad',
+      phase: 'analyze',
+      feature_slug: null,
+    });
+  });
+
+  it('大小写归一化：BMAD/DESIGN:Login-Feature → 全部小写', () => {
+    expect(parseWorkflowMeta('BMAD/DESIGN:Login-Feature')).toEqual({
+      workflow: 'bmad',
+      phase: 'design',
+      feature_slug: 'login-feature',
+    });
+  });
+
+  it('容忍尾部空白', () => {
+    expect(parseWorkflowMeta('bmad/analyze   ')).toEqual({
+      workflow: 'bmad',
+      phase: 'analyze',
+      feature_slug: null,
+    });
+  });
+
+  it('非法格式（空格在中间、workflow/phase 不符合规则）→ 全部为 null', () => {
+    expect(parseWorkflowMeta('bmad / analyze')).toEqual({
+      workflow: null,
+      phase: null,
+      feature_slug: null,
+    });
+    expect(parseWorkflowMeta('代码审查')).toEqual({
+      workflow: null,
+      phase: null,
+      feature_slug: null,
+    });
+    // 数字开头不允许
+    expect(parseWorkflowMeta('1bmad/analyze')).toEqual({
+      workflow: null,
+      phase: null,
+      feature_slug: null,
+    });
+  });
+
+  it('支持中文 feature_slug', () => {
+    expect(parseWorkflowMeta('bmad/analyze:用户认证')).toEqual({
+      workflow: 'bmad',
+      phase: 'analyze',
+      feature_slug: '用户认证',
+    });
+  });
+
+  it('支持日文 feature_slug', () => {
+    expect(parseWorkflowMeta('harness/reproduce:ログイン機能')).toEqual({
+      workflow: 'harness',
+      phase: 'reproduce',
+      feature_slug: 'ログイン機能',
+    });
+  });
+
+  it('支持混合字符 feature_slug', () => {
+    expect(parseWorkflowMeta('bmad/design:user-auth-用户认证')).toEqual({
+      workflow: 'bmad',
+      phase: 'design',
+      feature_slug: 'user-auth-用户认证',
+    });
+  });
+
+  it('feature_slug 不允许包含空格或冒号', () => {
+    expect(parseWorkflowMeta('bmad/analyze:user auth')).toEqual({
+      workflow: null,
+      phase: null,
+      feature_slug: null,
+    });
+    expect(parseWorkflowMeta('bmad/analyze:user:auth')).toEqual({
+      workflow: null,
+      phase: null,
+      feature_slug: null,
+    });
+  });
+});
+
+describe('SQLiteStorage: skill_invocations 工作流字段', () => {
+  let tmp: string;
+  let dbPath: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-skill-wf-'));
+    dbPath = join(tmp, 'data.db');
+    storage = new SQLiteStorage(dbPath);
+  });
+
+  afterEach(() => {
+    try {
+      storage.getDatabase().close();
+    } catch {
+      // already closed
+    }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('writeSkillInvocation 写入工作流字段后 query 能正确返回', () => {
+    storage.writeSkillInvocation({
+      id: 'inv-1',
+      route_request_id: 'route-A',
+      session_id: 'sess-1',
+      agent_id: 'agent-x',
+      skill_id: 'official-tdd',
+      invocation_type: 'dynamic',
+      reason: 'bmad/analyze',
+      workflow: 'bmad',
+      phase: 'analyze',
+      feature_slug: null,
+      artifact_path: null,
+      depth: 0,
+      success: 1,
+      error: null,
+      timestamp: Date.now(),
+    });
+
+    const rows = storage.querySkillInvocations({ session_id: 'sess-1' });
+    expect(rows).toHaveLength(1);
+    expect(rows[0].workflow).toBe('bmad');
+    expect(rows[0].phase).toBe('analyze');
+    expect(rows[0].feature_slug).toBeNull();
+    expect(rows[0].artifact_path).toBeNull();
+  });
+
+  it('feature_slug + artifact_path 写入回读', () => {
+    storage.writeSkillInvocation({
+      id: 'inv-2',
+      route_request_id: 'route-B',
+      session_id: 'sess-1',
+      agent_id: null,
+      skill_id: 'official-design',
+      invocation_type: 'dynamic',
+      reason: 'bmad/design:login-feature',
+      workflow: 'bmad',
+      phase: 'design',
+      feature_slug: 'login-feature',
+      artifact_path: 'docs/login.md',
+      depth: 0,
+      success: 1,
+      error: null,
+      timestamp: Date.now(),
+    });
+
+    const rows = storage.querySkillInvocations({ session_id: 'sess-1' });
+    expect(rows[0].feature_slug).toBe('login-feature');
+    expect(rows[0].artifact_path).toBe('docs/login.md');
+  });
+
+  it('null 工作流字段写入回读为 null（向后兼容）', () => {
+    storage.writeSkillInvocation({
+      id: 'inv-3',
+      route_request_id: null,
+      session_id: 'sess-2',
+      agent_id: null,
+      skill_id: 'plain-skill',
+      invocation_type: 'dynamic',
+      reason: '普通调用，没有工作流标记',
+      workflow: null,
+      phase: null,
+      feature_slug: null,
+      artifact_path: null,
+      depth: 0,
+      success: 1,
+      error: null,
+      timestamp: Date.now(),
+    });
+
+    const rows = storage.querySkillInvocations({ session_id: 'sess-2' });
+    expect(rows[0].workflow).toBeNull();
+    expect(rows[0].phase).toBeNull();
+  });
+});
+
+describe('SQLiteStorage: queryWorkflowProgress', () => {
+  let tmp: string;
+  let dbPath: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-wf-progress-'));
+    dbPath = join(tmp, 'data.db');
+    storage = new SQLiteStorage(dbPath);
+  });
+
+  afterEach(() => {
+    try {
+      storage.getDatabase().close();
+    } catch {
+      // already closed
+    }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  function seed(
+    overrides: Partial<{
+      route_request_id: string;
+      session_id: string;
+      workflow: string | null;
+      phase: string | null;
+      feature_slug: string | null;
+      success: number;
+      timestamp: number;
+    }>,
+  ): void {
+    const t = overrides.timestamp ?? Date.now();
+    storage.writeSkillInvocation({
+      id: randomUUID(),
+      route_request_id: overrides.route_request_id ?? 'route-default',
+      session_id: overrides.session_id ?? 'sess-1',
+      agent_id: 'agent-x',
+      skill_id: 'skill-x',
+      invocation_type: 'dynamic',
+      reason: 'seed',
+      workflow: overrides.workflow ?? null,
+      phase: overrides.phase ?? null,
+      feature_slug: overrides.feature_slug ?? null,
+      artifact_path: null,
+      depth: 0,
+      success: overrides.success ?? 1,
+      error: null,
+      timestamp: t,
+    });
+  }
+
+  it('按 route_request_id 聚合 phases，按时间顺序排列且去重', () => {
+    const base = Date.now();
+    seed({ route_request_id: 'route-A', workflow: 'bmad', phase: 'analyze', timestamp: base + 100 });
+    seed({ route_request_id: 'route-A', workflow: 'bmad', phase: 'design', timestamp: base + 200 });
+    // 同 phase 重复调用，去重后只算一次
+    seed({ route_request_id: 'route-A', workflow: 'bmad', phase: 'design', timestamp: base + 300 });
+    seed({ route_request_id: 'route-A', workflow: 'bmad', phase: 'implement', timestamp: base + 400 });
+
+    const result = storage.queryWorkflowProgress({ session_id: 'sess-1' });
+    expect(result).toHaveLength(1);
+    expect(result[0].route_request_id).toBe('route-A');
+    expect(result[0].workflow).toBe('bmad');
+    expect(result[0].phases_completed).toEqual(['analyze', 'design', 'implement']);
+    expect(result[0].total_invocations).toBe(4);
+    expect(result[0].success_count).toBe(4);
+    expect(result[0].first_at).toBe(base + 100);
+    expect(result[0].last_at).toBe(base + 400);
+  });
+
+  it('忽略 workflow 为 null 的调用', () => {
+    const base = Date.now();
+    seed({ route_request_id: 'route-A', workflow: 'bmad', phase: 'analyze', timestamp: base + 100 });
+    // 普通调用，不应被纳入聚合
+    seed({ route_request_id: 'route-A', workflow: null, phase: null, timestamp: base + 200 });
+
+    const result = storage.queryWorkflowProgress({ session_id: 'sess-1' });
+    expect(result[0].total_invocations).toBe(1);
+    expect(result[0].phases_completed).toEqual(['analyze']);
+  });
+
+  it('按 workflow 过滤', () => {
+    const base = Date.now();
+    seed({ route_request_id: 'route-A', workflow: 'bmad', phase: 'analyze', timestamp: base + 100 });
+    seed({ route_request_id: 'route-B', workflow: 'harness', phase: 'safety-net', timestamp: base + 200 });
+
+    const bmadOnly = storage.queryWorkflowProgress({ workflow: 'bmad' });
+    expect(bmadOnly).toHaveLength(1);
+    expect(bmadOnly[0].workflow).toBe('bmad');
+
+    const harnessOnly = storage.queryWorkflowProgress({ workflow: 'harness' });
+    expect(harnessOnly).toHaveLength(1);
+    expect(harnessOnly[0].workflow).toBe('harness');
+  });
+
+  it('feature_slug 取首个非空值，success_count 正确累加', () => {
+    const base = Date.now();
+    seed({
+      route_request_id: 'route-A',
+      workflow: 'bmad',
+      phase: 'analyze',
+      feature_slug: 'login',
+      success: 1,
+      timestamp: base + 100,
+    });
+    seed({
+      route_request_id: 'route-A',
+      workflow: 'bmad',
+      phase: 'design',
+      feature_slug: 'login',
+      success: 0,
+      timestamp: base + 200,
+    });
+
+    const result = storage.queryWorkflowProgress({ session_id: 'sess-1' });
+    expect(result[0].feature_slug).toBe('login');
+    expect(result[0].total_invocations).toBe(2);
+    expect(result[0].success_count).toBe(1);
+  });
+
+  it('多个 route 时按 last_at DESC 排序', () => {
+    const base = Date.now();
+    seed({ route_request_id: 'route-old', workflow: 'bmad', phase: 'analyze', timestamp: base + 100 });
+    seed({ route_request_id: 'route-new', workflow: 'bmad', phase: 'analyze', timestamp: base + 1000 });
+
+    const result = storage.queryWorkflowProgress({ session_id: 'sess-1' });
+    expect(result).toHaveLength(2);
+    expect(result[0].route_request_id).toBe('route-new');
+    expect(result[1].route_request_id).toBe('route-old');
+  });
+
+  it('无匹配时返回空数组', () => {
+    seed({ route_request_id: 'route-A', workflow: null, phase: null });
+    const result = storage.queryWorkflowProgress({ session_id: 'sess-1' });
+    expect(result).toEqual([]);
+  });
+});
+
+describe('SQLiteStorage: skill_invocations 增量迁移', () => {
+  let tmp: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-skill-mig-'));
+    dbPath = join(tmp, 'data.db');
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('旧库（没有 workflow / phase / feature_slug / artifact_path 列）经 runMigrations 后字段被加上', () => {
+    // Step 1: 模拟旧版本数据库 — 直接用 better-sqlite3 建一个旧 schema 的 skill_invocations 表
+    const legacyDb = new Database(dbPath);
+    legacyDb.exec(`
+      CREATE TABLE skill_invocations (
+        id TEXT PRIMARY KEY,
+        route_request_id TEXT,
+        session_id TEXT NOT NULL,
+        agent_id TEXT,
+        skill_id TEXT NOT NULL,
+        invocation_type TEXT NOT NULL,
+        reason TEXT,
+        depth INTEGER DEFAULT 0,
+        success INTEGER DEFAULT 1,
+        error TEXT,
+        timestamp INTEGER NOT NULL,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+    `);
+    // 写一行旧数据
+    legacyDb.prepare(`
+      INSERT INTO skill_invocations
+        (id, route_request_id, session_id, agent_id, skill_id, invocation_type, reason, depth, success, error, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      'legacy-1',
+      'route-legacy',
+      'sess-legacy',
+      'agent-old',
+      'old-skill',
+      'dynamic',
+      'old reason',
+      0,
+      1,
+      null,
+      Date.now() - 10000,
+    );
+
+    // 验证旧库不存在新列
+    const oldCols = legacyDb.prepare(`PRAGMA table_info(skill_invocations)`).all() as Array<{ name: string }>;
+    const oldNames = oldCols.map(c => c.name);
+    expect(oldNames).not.toContain('workflow');
+    expect(oldNames).not.toContain('phase');
+    expect(oldNames).not.toContain('feature_slug');
+    expect(oldNames).not.toContain('artifact_path');
+    legacyDb.close();
+
+    // Step 2: 用 SQLiteStorage 打开同一个 db 文件，runMigrations 应自动补齐列
+    const storage = new SQLiteStorage(dbPath);
+    try {
+      // 验证新列已加上
+      const newCols = storage
+        .getDatabase()
+        .prepare(`PRAGMA table_info(skill_invocations)`)
+        .all() as Array<{ name: string }>;
+      const newNames = newCols.map(c => c.name);
+      expect(newNames).toContain('workflow');
+      expect(newNames).toContain('phase');
+      expect(newNames).toContain('feature_slug');
+      expect(newNames).toContain('artifact_path');
+
+      // 旧数据应该还在，且新列默认为 NULL
+      const legacyRows = storage.querySkillInvocations({ session_id: 'sess-legacy' });
+      expect(legacyRows).toHaveLength(1);
+      expect(legacyRows[0].id).toBe('legacy-1');
+      expect(legacyRows[0].workflow).toBeNull();
+      expect(legacyRows[0].phase).toBeNull();
+      expect(legacyRows[0].feature_slug).toBeNull();
+      expect(legacyRows[0].artifact_path).toBeNull();
+
+      // 新数据可以正常写入工作流字段
+      storage.writeSkillInvocation({
+        id: 'new-1',
+        route_request_id: 'route-new',
+        session_id: 'sess-legacy',
+        agent_id: 'agent-new',
+        skill_id: 'official-tdd',
+        invocation_type: 'dynamic',
+        reason: 'bmad/analyze',
+        workflow: 'bmad',
+        phase: 'analyze',
+        feature_slug: null,
+        artifact_path: null,
+        depth: 0,
+        success: 1,
+        error: null,
+        timestamp: Date.now(),
+      });
+
+      const allRows = storage.querySkillInvocations({ session_id: 'sess-legacy' });
+      expect(allRows).toHaveLength(2);
+      const newRow = allRows.find(r => r.id === 'new-1');
+      expect(newRow?.workflow).toBe('bmad');
+      expect(newRow?.phase).toBe('analyze');
+
+      // 验证新索引已创建
+      const indexes = storage
+        .getDatabase()
+        .prepare(`SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='skill_invocations'`)
+        .all() as Array<{ name: string }>;
+      const indexNames = indexes.map(i => i.name);
+      expect(indexNames).toContain('idx_skill_invocations_workflow');
+      expect(indexNames).toContain('idx_skill_invocations_feature');
+    } finally {
+      storage.getDatabase().close();
+    }
+  });
+});

package/tests/unit/skill-registry.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect, vi, beforeAll, afterAll } from 'vitest';
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+// Set up temp dir before module import (SKILLS_DIR is computed at load time)
+const tempDir = mkdtempSync(join(tmpdir(), 'forge-test-'));
+const skillsDir = join(tempDir, '.claude', 'skills');
+mkdirSync(skillsDir, { recursive: true });
+
+writeFileSync(
+  join(skillsDir, 'refactor.md'),
+  `---\nname: "Refactor Skill"\nkeywords: ["refactor", "重构", "cleanup", "restructure"]\n---\nThis skill helps with refactoring.`
+);
+writeFileSync(
+  join(skillsDir, 'debug.md'),
+  `---\nname: "Debug Skill"\nkeywords: ["debug", "调试", "bug"]\n---\nThis skill helps with debugging.`
+);
+
+vi.mock('node:os', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:os')>();
+  return { ...actual, homedir: () => tempDir };
+});
+
+// Import after mock is set up
+const { SkillRegistry } = await import('../../src/skills/registry.js');
+
+describe('SkillRegistry', () => {
+  afterAll(() => {
+    vi.restoreAllMocks();
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('scan', () => {
+    it('loads official skills plus user skills from ~/.claude/skills/', () => {
+      const registry = new SkillRegistry();
+      const skills = registry.getAll();
+
+      // 17 official skills + 2 user skills (user 'debug' overrides official 'official-debug' by different id)
+      expect(skills.length).toBeGreaterThanOrEqual(17);
+      expect(skills.map(s => s.id)).toContain('refactor');
+      expect(skills.map(s => s.id)).toContain('debug');
+      // Official skills should be present
+      expect(skills.map(s => s.id)).toContain('official-harness-engineering');
+    });
+  });
+
+  describe('match', () => {
+    it('returns a skill when keywords match', async () => {
+      const registry = new SkillRegistry();
+      const skill = await registry.match('I need to refactor and cleanup this code');
+
+      expect(skill).not.toBeNull();
+      expect(skill!.name).toBe('Refactor Skill');
+    });
+
+    it('returns null when no match', async () => {
+      const registry = new SkillRegistry();
+      const skill = await registry.match('just a simple task');
+
+      expect(skill).toBeNull();
+    });
+
+    it('matches Chinese keywords', async () => {
+      const registry = new SkillRegistry();
+      const skill = await registry.match('需要重构和cleanup这个模块');
+
+      expect(skill).not.toBeNull();
+      expect(skill!.name).toBe('Refactor Skill');
+    });
+
+    it('matches extra keywords parameter', async () => {
+      const registry = new SkillRegistry();
+      const skill = await registry.match('help me', ['debug', 'issue']);
+
+      expect(skill).not.toBeNull();
+      // Either official-debug or user debug skill can match (official loads first)
+      expect(skill!.keywords).toContain('debug');
+    });
+  });
+
+  describe('getAll', () => {
+    it('returns all loaded skills (official + user)', () => {
+      const registry = new SkillRegistry();
+      const skills = registry.getAll();
+
+      // 17 official + 2 user = 19
+      expect(skills.length).toBeGreaterThanOrEqual(17);
+      // User skills should be present alongside official ones
+      const userSkills = skills.filter(s => !s.isOfficial);
+      expect(userSkills.length).toBe(2);
+    });
+  });
+});