@winspan/claude-forge 8.53.2 → 8.54.3

package/tests/unit/skills/invocation-guard-ttl.test.ts

@@ -1,211 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { InvocationGuard } from '../../../src/skills/invocation-guard.js';
-
-describe('InvocationGuard - TTL Mechanism', () => {
-  let guard: InvocationGuard;
-
-  beforeEach(() => {
-    guard = new InvocationGuard();
-  });
-
-  afterEach(() => {
-    guard.stopCleanupTimer();
-  });
-
-  describe('TTL expiration', () => {
-    it('should allow invocation after session expires', () => {
-      const sessionId = 'test-session-1';
-      const skillId = 'test-skill';
-
-      // Record initial invocation
-      guard.record(sessionId, skillId);
-
-      // Verify skill is blocked (idempotent guard)
-      let result = guard.check(sessionId, skillId);
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toContain('already invoked');
-
-      // Fast-forward time by 31 minutes (beyond TTL)
-      const stats = guard.getStats(sessionId);
-      if (stats) {
-        stats.lastAccessTime = Date.now() - 31 * 60 * 1000;
-      }
-
-      // Should allow invocation after expiration
-      result = guard.check(sessionId, skillId);
-      expect(result.allowed).toBe(true);
-    });
-
-    it('should update lastAccessTime on record', () => {
-      const sessionId = 'test-session-2';
-      const skillId = 'test-skill';
-
-      const before = Date.now();
-      guard.record(sessionId, skillId);
-      const after = Date.now();
-
-      const stats = guard.getStats(sessionId);
-      expect(stats).not.toBeNull();
-      expect(stats!.lastAccessTime).toBeGreaterThanOrEqual(before);
-      expect(stats!.lastAccessTime).toBeLessThanOrEqual(after);
-    });
-
-    it('should update lastAccessTime on complete', () => {
-      const sessionId = 'test-session-3';
-      const skillId = 'test-skill';
-
-      guard.record(sessionId, skillId);
-      const initialTime = guard.getStats(sessionId)!.lastAccessTime;
-
-      // Wait a bit
-      vi.useFakeTimers();
-      vi.advanceTimersByTime(1000);
-
-      guard.complete(sessionId);
-      const updatedTime = guard.getStats(sessionId)!.lastAccessTime;
-
-      expect(updatedTime).toBeGreaterThan(initialTime);
-
-      vi.useRealTimers();
-    });
-  });
-
-  describe('automatic cleanup', () => {
-    it('should clean up expired sessions', () => {
-      const sessionId1 = 'expired-session-1';
-      const sessionId2 = 'active-session-2';
-
-      // Record two sessions
-      guard.record(sessionId1, 'skill-1');
-      guard.record(sessionId2, 'skill-2');
-
-      expect(guard.getSessionCount()).toBe(2);
-
-      // Expire first session
-      const stats1 = guard.getStats(sessionId1);
-      if (stats1) {
-        stats1.lastAccessTime = Date.now() - 31 * 60 * 1000;
-      }
-
-      // Trigger cleanup manually
-      (guard as any).cleanupExpiredSessions();
-
-      // Only active session should remain
-      expect(guard.getSessionCount()).toBe(1);
-      expect(guard.getStats(sessionId1)).toBeNull();
-      expect(guard.getStats(sessionId2)).not.toBeNull();
-    });
-
-    it('should not clean up active sessions', () => {
-      const sessionId = 'active-session';
-
-      guard.record(sessionId, 'skill-1');
-      expect(guard.getSessionCount()).toBe(1);
-
-      // Trigger cleanup
-      (guard as any).cleanupExpiredSessions();
-
-      // Session should still exist
-      expect(guard.getSessionCount()).toBe(1);
-      expect(guard.getStats(sessionId)).not.toBeNull();
-    });
-
-    it('should handle empty sessions map', () => {
-      expect(guard.getSessionCount()).toBe(0);
-
-      // Should not throw
-      expect(() => {
-        (guard as any).cleanupExpiredSessions();
-      }).not.toThrow();
-
-      expect(guard.getSessionCount()).toBe(0);
-    });
-  });
-
-  describe('cleanup timer', () => {
-    it('should start cleanup timer on construction', () => {
-      const newGuard = new InvocationGuard();
-      expect((newGuard as any).cleanupTimer).not.toBeNull();
-      newGuard.stopCleanupTimer();
-    });
-
-    it('should stop cleanup timer', () => {
-      guard.stopCleanupTimer();
-      expect((guard as any).cleanupTimer).toBeNull();
-    });
-
-    it('should not start multiple timers', () => {
-      const timer1 = (guard as any).cleanupTimer;
-      (guard as any).startCleanupTimer();
-      const timer2 = (guard as any).cleanupTimer;
-
-      expect(timer1).toBe(timer2);
-    });
-  });
-
-  describe('getSessionCount', () => {
-    it('should return 0 for empty guard', () => {
-      expect(guard.getSessionCount()).toBe(0);
-    });
-
-    it('should return correct count after recording', () => {
-      guard.record('session-1', 'skill-1');
-      expect(guard.getSessionCount()).toBe(1);
-
-      guard.record('session-2', 'skill-2');
-      expect(guard.getSessionCount()).toBe(2);
-    });
-
-    it('should decrease count after clear', () => {
-      guard.record('session-1', 'skill-1');
-      guard.record('session-2', 'skill-2');
-      expect(guard.getSessionCount()).toBe(2);
-
-      guard.clear('session-1');
-      expect(guard.getSessionCount()).toBe(1);
-    });
-  });
-
-  describe('integration with existing functionality', () => {
-    it('should maintain depth tracking with TTL', () => {
-      const sessionId = 'test-session';
-
-      guard.record(sessionId, 'skill-1');
-      expect(guard.getStats(sessionId)!.depth).toBe(1);
-
-      guard.record(sessionId, 'skill-2');
-      expect(guard.getStats(sessionId)!.depth).toBe(2);
-
-      guard.complete(sessionId);
-      expect(guard.getStats(sessionId)!.depth).toBe(1);
-
-      // lastAccessTime should be updated
-      expect(guard.getStats(sessionId)!.lastAccessTime).toBeLessThanOrEqual(Date.now());
-    });
-
-    it('should maintain total count with TTL', () => {
-      const sessionId = 'test-session';
-
-      guard.record(sessionId, 'skill-1');
-      expect(guard.getStats(sessionId)!.total).toBe(1);
-
-      guard.record(sessionId, 'skill-2');
-      expect(guard.getStats(sessionId)!.total).toBe(2);
-
-      // lastAccessTime should be updated
-      expect(guard.getStats(sessionId)!.lastAccessTime).toBeLessThanOrEqual(Date.now());
-    });
-
-    it('should maintain calledSkills set with TTL', () => {
-      const sessionId = 'test-session';
-
-      guard.record(sessionId, 'skill-1');
-      guard.record(sessionId, 'skill-2');
-
-      const stats = guard.getStats(sessionId);
-      expect(stats!.calledSkills.has('skill-1')).toBe(true);
-      expect(stats!.calledSkills.has('skill-2')).toBe(true);
-      expect(stats!.lastAccessTime).toBeLessThanOrEqual(Date.now());
-    });
-  });
-});

package/tests/unit/skills/official-skills-loader.test.ts

@@ -1,126 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { loadOfficialSkills } from '../../../src/skills/official-skills.js';
-
-describe('loadOfficialSkills', () => {
-  let tempDir: string;
-
-  beforeAll(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'forge-official-skills-test-'));
-  });
-
-  afterAll(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it('loads all .md files from the given directory', () => {
-    writeFileSync(
-      join(tempDir, 'test-skill-a.md'),
-      `---\nname: test-skill-a\nversion: 1.0.0\ndescription: "Test skill A"\ntags: [tag1, tag2]\n---\n\n# Test Skill A\n\nBody content here.`
-    );
-    writeFileSync(
-      join(tempDir, 'test-skill-b.md'),
-      `---\nname: test-skill-b\nversion: 2.0.0\ndescription: "Test skill B"\nkeywords: [kw1, kw2]\n---\n\n# Test Skill B\n\nMore content.`
-    );
-
-    const skills = loadOfficialSkills(tempDir);
-    const names = skills.map(s => s.name);
-    expect(names).toContain('test-skill-a');
-    expect(names).toContain('test-skill-b');
-    expect(skills.length).toBeGreaterThanOrEqual(2);
-  });
-
-  it('parses frontmatter correctly (name, version, description, keywords from tags)', () => {
-    const skillDir = mkdtempSync(join(tmpdir(), 'forge-frontmatter-test-'));
-    try {
-      writeFileSync(
-        join(skillDir, 'my-skill.md'),
-        `---\nname: my-skill\nversion: 3.1.0\ndescription: "My test skill"\ntags: [alpha, beta, gamma]\n---\n\n# My Skill\n\nContent.`
-      );
-
-      const skills = loadOfficialSkills(skillDir);
-      expect(skills).toHaveLength(1);
-      const skill = skills[0];
-      expect(skill.name).toBe('my-skill');
-      expect(skill.version).toBe('3.1.0');
-      expect(skill.description).toBe('My test skill');
-      expect(skill.keywords).toEqual(['alpha', 'beta', 'gamma']);
-    } finally {
-      rmSync(skillDir, { recursive: true, force: true });
-    }
-  });
-
-  it('parses frontmatter correctly (keywords field takes precedence over tags)', () => {
-    const skillDir = mkdtempSync(join(tmpdir(), 'forge-kw-test-'));
-    try {
-      writeFileSync(
-        join(skillDir, 'kw-skill.md'),
-        `---\nname: kw-skill\nversion: 1.0.0\ndescription: "KW skill"\nkeywords: [kw-a, kw-b]\ntags: [tag-a]\n---\n\n# KW Skill`
-      );
-
-      const skills = loadOfficialSkills(skillDir);
-      expect(skills).toHaveLength(1);
-      // keywords takes precedence (data.keywords ?? data.tags => keywords wins)
-      expect(skills[0].keywords).toEqual(['kw-a', 'kw-b']);
-    } finally {
-      rmSync(skillDir, { recursive: true, force: true });
-    }
-  });
-
-  it('falls back to filename as name when frontmatter name is missing', () => {
-    const skillDir = mkdtempSync(join(tmpdir(), 'forge-fallback-test-'));
-    try {
-      writeFileSync(
-        join(skillDir, 'unnamed-skill.md'),
-        `---\nversion: 1.0.0\n---\n\n# Unnamed Skill`
-      );
-
-      const skills = loadOfficialSkills(skillDir);
-      expect(skills).toHaveLength(1);
-      expect(skills[0].name).toBe('unnamed-skill');
-    } finally {
-      rmSync(skillDir, { recursive: true, force: true });
-    }
-  });
-
-  it('ignores non-.md files in the directory', () => {
-    const skillDir = mkdtempSync(join(tmpdir(), 'forge-nonmd-test-'));
-    try {
-      writeFileSync(join(skillDir, 'skill.md'), `---\nname: skill\n---\n# Skill`);
-      writeFileSync(join(skillDir, 'README.txt'), 'not a skill');
-      writeFileSync(join(skillDir, 'index.json'), '{}');
-
-      const skills = loadOfficialSkills(skillDir);
-      expect(skills).toHaveLength(1);
-      expect(skills[0].name).toBe('skill');
-    } finally {
-      rmSync(skillDir, { recursive: true, force: true });
-    }
-  });
-
-  it('throws a meaningful error when directory does not exist', () => {
-    const nonExistentDir = join(tmpdir(), 'forge-does-not-exist-' + Date.now());
-    expect(() => loadOfficialSkills(nonExistentDir)).toThrow(/Official skills directory not found/);
-  });
-
-  it('loads all official skills from the actual built-in directory', async () => {
-    // Verify the real built-in directory works end-to-end
-    const { fileURLToPath } = await import('node:url');
-    const { dirname, join: pathJoin } = await import('node:path');
-    const thisDir = dirname(fileURLToPath(import.meta.url));
-    const builtinDir = pathJoin(thisDir, '../../../src/skills/official');
-
-    const skills = loadOfficialSkills(builtinDir);
-    // Should have 17 official skills
-    expect(skills.length).toBeGreaterThanOrEqual(17);
-    // Spot-check a known skill
-    const harness = skills.find(s => s.name === 'official-harness-engineering');
-    expect(harness).toBeDefined();
-    expect(harness!.version).toBe('2.0.1');
-    expect(harness!.description).toContain('Harness Engineering');
-    // path should NOT be '<built-in>'
-    expect(harness!.name).toBe('official-harness-engineering');
-  });
-});

package/tests/unit/skills/registry-multiformat.test.ts

@@ -1,92 +0,0 @@
-/**
- * Unit tests for SkillRegistry multi-format support
- * Tests both flat .md and directory-based SKILL.md formats
- */
-
-import { describe, it, expect } from 'vitest';
-import matter from 'gray-matter';
-
-describe('SkillRegistry - Multi-format Support', () => {
-  it('should parse flat .md format with description', () => {
-    const flatSkillContent = `---
-name: flat-skill
-description: A flat format skill for testing
-keywords: [test, flat, format]
----
-
-# Flat Skill
-
-This is a flat format skill.`;
-
-    const parsed = matter(flatSkillContent);
-    expect(parsed.data.name).toBe('flat-skill');
-    expect(parsed.data.description).toBe('A flat format skill for testing');
-    expect(parsed.data.keywords).toEqual(['test', 'flat', 'format']);
-    expect(parsed.content.trim()).toContain('# Flat Skill');
-  });
-
-  it('should parse directory format SKILL.md with description', () => {
-    const dirSkillContent = `---
-name: dir-skill
-description: A directory format skill from agent-skills
-keywords: [agent, directory, skill]
----
-
-# Directory Skill
-
-This is a directory format skill (agent-skills format).`;
-
-    const parsed = matter(dirSkillContent);
-    expect(parsed.data.name).toBe('dir-skill');
-    expect(parsed.data.description).toBe('A directory format skill from agent-skills');
-    expect(parsed.data.keywords).toEqual(['agent', 'directory', 'skill']);
-    expect(parsed.content.trim()).toContain('# Directory Skill');
-  });
-
-  it('should handle skills without keywords', () => {
-    const noKeywordsContent = `---
-name: no-keywords-skill
-description: A skill without keywords for fallback testing
----
-
-# No Keywords Skill
-
-This skill has no keywords, should fallback to description matching.`;
-
-    const parsed = matter(noKeywordsContent);
-    expect(parsed.data.name).toBe('no-keywords-skill');
-    expect(parsed.data.description).toBe('A skill without keywords for fallback testing');
-    expect(parsed.data.keywords).toBeUndefined();
-    expect(parsed.content.trim()).toContain('# No Keywords Skill');
-  });
-
-  it('should handle skills without description', () => {
-    const noDescContent = `---
-name: no-desc-skill
-keywords: [test, nodesc]
----
-
-# No Description Skill
-
-This skill has no description field.`;
-
-    const parsed = matter(noDescContent);
-    expect(parsed.data.name).toBe('no-desc-skill');
-    expect(parsed.data.description).toBeUndefined();
-    expect(parsed.data.keywords).toEqual(['test', 'nodesc']);
-  });
-
-  it('should handle empty frontmatter gracefully', () => {
-    const emptyFrontmatterContent = `---
----
-
-# Minimal Skill
-
-Just content, no metadata.`;
-
-    const parsed = matter(emptyFrontmatterContent);
-    expect(parsed.data).toEqual({});
-    expect(parsed.content.trim()).toContain('# Minimal Skill');
-  });
-});
-

package/tests/unit/skills/upgrade-engine-parse.test.ts

@@ -1,138 +0,0 @@
-/**
- * Tests for AI response parsing in upgrade-engine.ts (evaluateWithAI edge cases).
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { evaluateWithAI } from '../../../src/skills/upgrade-engine.js';
-import type { CandidateSkill } from '../../../src/skills/upgrade-engine.js';
-import type { OfficialSkill } from '../../../src/skills/official-skills.js';
-import type { ClaudeProvider } from '../../../src/core/ai/provider.js';
-
-const candidate: CandidateSkill = {
-  id: 'test-skill',
-  source: 'agent-skills',
-  filePath: '/tmp/test/SKILL.md',
-  name: 'test-skill',
-  description: 'A test skill',
-  keywords: ['test'],
-  content: '# Test Skill',
-};
-
-const official: OfficialSkill = {
-  name: 'official-test',
-  version: '1.0.0',
-  description: 'Official test skill',
-  keywords: ['test'],
-  content: '# Official Test Skill',
-};
-
-function makeProvider(value: string): ClaudeProvider {
-  return {
-    complete: vi.fn().mockResolvedValue(value),
-  } as unknown as ClaudeProvider;
-}
-
-describe('evaluateWithAI — response parsing', () => {
-  it('non-JSON text → needs_review=true, action=skip', async () => {
-    const provider = makeProvider('Sorry, I cannot evaluate this.');
-    const result = await evaluateWithAI(candidate, official, provider);
-    expect(result.needs_review).toBe(true);
-    expect(result.action).toBe('skip');
-    expect(result.confidence).toBe(0);
-  });
-
-  it('partial JSON (truncated) → needs_review=true', async () => {
-    const provider = makeProvider('{"action":"upgrade","confidence":80,');
-    const result = await evaluateWithAI(candidate, official, provider);
-    expect(result.needs_review).toBe(true);
-  });
-
-  it('valid JSON with action=upgrade → parsed correctly', async () => {
-    const json = JSON.stringify({
-      action: 'upgrade',
-      confidence: 90,
-      reasoning: '候选质量更高',
-      merged_content: null,
-    });
-    const provider = makeProvider(json);
-    const result = await evaluateWithAI(candidate, official, provider);
-    expect(result.action).toBe('upgrade');
-    expect(result.confidence).toBe(90);
-    expect(result.reasoning).toBe('候选质量更高');
-    expect(result.needs_review).toBeUndefined();
-  });
-
-  it('valid JSON with action=merge and merged_content → parsed correctly', async () => {
-    const mergedMd = '---\nname: merged\n---\n# Merged';
-    const json = JSON.stringify({
-      action: 'merge',
-      confidence: 75,
-      reasoning: '各有特色章节',
-      merged_content: mergedMd,
-    });
-    const provider = makeProvider(json);
-    const result = await evaluateWithAI(candidate, official, provider);
-    expect(result.action).toBe('merge');
-    expect(result.merged_content).toBe(mergedMd);
-  });
-
-  it('JSON with unknown action → defaults to skip', async () => {
-    const json = JSON.stringify({
-      action: 'replace', // invalid
-      confidence: 60,
-      reasoning: 'bad action',
-      merged_content: null,
-    });
-    const provider = makeProvider(json);
-    const result = await evaluateWithAI(candidate, official, provider);
-    expect(result.action).toBe('skip');
-  });
-
-  it('JSON missing confidence → defaults to 0', async () => {
-    const json = JSON.stringify({ action: 'skip', reasoning: 'ok', merged_content: null });
-    const provider = makeProvider(json);
-    const result = await evaluateWithAI(candidate, official, provider);
-    expect(result.confidence).toBe(0);
-  });
-
-  it('response wrapped in markdown code block → parsed correctly', async () => {
-    const json = JSON.stringify({
-      action: 'skip',
-      confidence: 40,
-      reasoning: 'wrapped',
-      merged_content: null,
-    });
-    const provider = makeProvider('```json\n' + json + '\n```');
-    const result = await evaluateWithAI(candidate, official, provider);
-    expect(result.action).toBe('skip');
-    expect(result.needs_review).toBeUndefined();
-  });
-
-  it('response wrapped in plain code block → parsed correctly', async () => {
-    const json = JSON.stringify({
-      action: 'merge',
-      confidence: 65,
-      reasoning: 'wrapped plain',
-      merged_content: null,
-    });
-    const provider = makeProvider('```\n' + json + '\n```');
-    const result = await evaluateWithAI(candidate, official, provider);
-    expect(result.action).toBe('merge');
-  });
-
-  it('API error → needs_review=true with error message in reasoning', async () => {
-    const provider = {
-      complete: vi.fn().mockRejectedValue(new Error('Network timeout')),
-    } as unknown as ClaudeProvider;
-
-    const result = await evaluateWithAI(candidate, official, provider);
-    expect(result.needs_review).toBe(true);
-    expect(result.reasoning).toContain('Network timeout');
-  });
-
-  it('empty string response → needs_review=true', async () => {
-    const provider = makeProvider('');
-    const result = await evaluateWithAI(candidate, official, provider);
-    expect(result.needs_review).toBe(true);
-  });
-});