@winspan/claude-forge 8.51.0 → 8.53.2

package/tests/unit/daemon/skill-sync.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { syncSkills } from '../../../src/daemon/skill-sync.js';
+
+describe('syncSkills', () => {
+  let tmpRoot: string;
+  let sourceDir: string;
+  let targetDir: string;
+
+  beforeEach(() => {
+    tmpRoot = mkdtempSync(join(tmpdir(), 'forge-skill-sync-'));
+    sourceDir = join(tmpRoot, 'src-skills');
+    targetDir = join(tmpRoot, 'target-skills');
+    mkdirSync(sourceDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tmpRoot, { recursive: true, force: true });
+  });
+
+  it('source dir not found → returns zero counts, does not throw', () => {
+    const result = syncSkills({ sourceDir: join(tmpRoot, 'nonexistent'), targetDir });
+    expect(result.copied).toBe(0);
+    expect(result.checked).toBe(0);
+    expect(result.skipped_userOwned).toBe(0);
+  });
+
+  it('source and target identical → copied=0, checked=1', () => {
+    const content = '# official-debug skill\nsome content\n';
+    writeFileSync(join(sourceDir, 'official-debug.md'), content);
+    mkdirSync(targetDir, { recursive: true });
+    writeFileSync(join(targetDir, 'official-debug.md'), content);
+
+    const result = syncSkills({ sourceDir, targetDir });
+    expect(result.copied).toBe(0);
+    expect(result.checked).toBe(1);
+  });
+
+  it('source and target differ → copied=1, target updated', () => {
+    writeFileSync(join(sourceDir, 'official-debug.md'), '# new content\n');
+    mkdirSync(targetDir, { recursive: true });
+    writeFileSync(join(targetDir, 'official-debug.md'), '# old content\n');
+
+    const result = syncSkills({ sourceDir, targetDir });
+    expect(result.copied).toBe(1);
+    expect(result.checked).toBe(1);
+    expect(readFileSync(join(targetDir, 'official-debug.md'), 'utf-8')).toContain('new content');
+  });
+
+  it('target missing file → copies it from source', () => {
+    writeFileSync(join(sourceDir, 'official-debug.md'), '# official-debug\n');
+    mkdirSync(targetDir, { recursive: true });
+    // target has no official-debug.md
+
+    const result = syncSkills({ sourceDir, targetDir });
+    expect(result.copied).toBe(1);
+    expect(existsSync(join(targetDir, 'official-debug.md'))).toBe(true);
+  });
+
+  it('user-only skill in target (not in source) → untouched', () => {
+    // source has one official skill
+    writeFileSync(join(sourceDir, 'official-debug.md'), '# official-debug\n');
+    mkdirSync(targetDir, { recursive: true });
+    // target also has a user-custom skill not present in source
+    writeFileSync(join(targetDir, 'my-custom-skill.md'), '# custom\n');
+
+    syncSkills({ sourceDir, targetDir });
+
+    // user skill must still exist and be unchanged
+    expect(existsSync(join(targetDir, 'my-custom-skill.md'))).toBe(true);
+    expect(readFileSync(join(targetDir, 'my-custom-skill.md'), 'utf-8')).toContain('custom');
+  });
+});

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

@@ -0,0 +1,138 @@
+/**
+ * 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);
+  });
+});

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

@@ -0,0 +1,401 @@
+/**
+ * Tests for upgrade-engine.ts — matchToOfficial, evaluateWithAI,
+ * generateReport, applyDecisions, and pullCandidates (partial).
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import {
+  matchToOfficial,
+  evaluateWithAI,
+  generateReport,
+  applyDecisions,
+} from '../../../src/skills/upgrade-engine.js';
+import type { CandidateSkill, ReportEntry } from '../../../src/skills/upgrade-engine.js';
+import type { OfficialSkill } from '../../../src/skills/official-skills.js';
+import type { ClaudeProvider } from '../../../src/core/ai/provider.js';
+
+// ── Fixtures ────────────────────────────────────────────────────────────────
+
+const officialSkills: OfficialSkill[] = [
+  {
+    name: 'official-db-schema-design',
+    version: '1.0.0',
+    description: '数据库设计方法论',
+    keywords: ['schema', 'database', 'sql', 'migration'],
+    content: '---\nname: official-db-schema-design\nversion: 1.0.0\n---\n# DB Schema Design\n\nOfficial content.',
+  },
+  {
+    name: 'official-debug',
+    version: '1.2.0',
+    description: '系统化调试工作流',
+    keywords: ['debug', 'bug', 'troubleshooting'],
+    content: '---\nname: official-debug\nversion: 1.2.0\n---\n# Debug\n\nOfficial debug content.',
+  },
+];
+
+function makeCandidate(overrides: Partial<CandidateSkill> = {}): CandidateSkill {
+  return {
+    id: 'database-design',
+    source: 'agent-skills',
+    filePath: '/tmp/agent-skills/database-design/SKILL.md',
+    name: 'database-design',
+    description: 'Database schema design patterns',
+    keywords: ['database', 'schema', 'sql'],
+    content: '---\nname: database-design\n---\n# Database Design\n\nContent here.',
+    ...overrides,
+  };
+}
+
+function makeMockProvider(returnValue: string): ClaudeProvider {
+  return {
+    complete: vi.fn().mockResolvedValue(returnValue),
+  } as unknown as ClaudeProvider;
+}
+
+// ── matchToOfficial ──────────────────────────────────────────────────────────
+
+describe('matchToOfficial', () => {
+  it('returns a match for a candidate with overlapping keywords', () => {
+    const candidate = makeCandidate();
+    const result = matchToOfficial(candidate, officialSkills);
+    expect(result).not.toBeNull();
+    expect(result?.officialId).toBe('official-db-schema-design');
+    expect(result?.score).toBeGreaterThanOrEqual(30);
+  });
+
+  it('returns null when score is below threshold (30)', () => {
+    const candidate = makeCandidate({
+      id: 'cooking-recipes',
+      name: 'cooking',
+      description: 'Culinary arts and baking',
+      keywords: ['cooking', 'baking', 'recipes', 'food'],
+    });
+    const result = matchToOfficial(candidate, officialSkills);
+    expect(result).toBeNull();
+  });
+
+  it('matches debug candidate to official-debug', () => {
+    const candidate = makeCandidate({
+      id: 'debug-helper',
+      name: 'debug-helper',
+      description: 'Debugging workflow',
+      keywords: ['debug', 'bug', 'troubleshoot'],
+    });
+    const result = matchToOfficial(candidate, officialSkills);
+    expect(result?.officialId).toBe('official-debug');
+  });
+
+  it('score is within 0-100 range', () => {
+    const candidate = makeCandidate();
+    const result = matchToOfficial(candidate, officialSkills);
+    if (result) {
+      expect(result.score).toBeGreaterThanOrEqual(0);
+      expect(result.score).toBeLessThanOrEqual(100);
+    }
+  });
+
+  it('returns null for empty official skills list', () => {
+    const candidate = makeCandidate();
+    const result = matchToOfficial(candidate, []);
+    expect(result).toBeNull();
+  });
+});
+
+// ── evaluateWithAI — three action paths ─────────────────────────────────────
+
+describe('evaluateWithAI', () => {
+  const official = officialSkills[0];
+  const candidate = makeCandidate();
+
+  it('returns upgrade decision when AI returns action=upgrade', async () => {
+    const json = JSON.stringify({
+      action: 'upgrade',
+      confidence: 85,
+      reasoning: '候选内容更全面',
+      merged_content: null,
+    });
+    const provider = makeMockProvider(json);
+    const result = await evaluateWithAI(candidate, official, provider);
+    expect(result.action).toBe('upgrade');
+    expect(result.confidence).toBe(85);
+    expect(result.reasoning).toBe('候选内容更全面');
+    expect(result.merged_content).toBeNull();
+  });
+
+  it('returns merge decision with merged_content', async () => {
+    const mergedMd = '---\nname: merged\n---\n# Merged Content';
+    const json = JSON.stringify({
+      action: 'merge',
+      confidence: 72,
+      reasoning: '各有独特章节',
+      merged_content: mergedMd,
+    });
+    const provider = makeMockProvider(json);
+    const result = await evaluateWithAI(candidate, official, provider);
+    expect(result.action).toBe('merge');
+    expect(result.merged_content).toBe(mergedMd);
+  });
+
+  it('returns skip decision when AI returns action=skip', async () => {
+    const json = JSON.stringify({
+      action: 'skip',
+      confidence: 30,
+      reasoning: '主题不重叠',
+      merged_content: null,
+    });
+    const provider = makeMockProvider(json);
+    const result = await evaluateWithAI(candidate, official, provider);
+    expect(result.action).toBe('skip');
+  });
+
+  it('returns needs_review when AI response is not valid JSON', async () => {
+    const provider = makeMockProvider('这不是JSON内容，AI出错了');
+    const result = await evaluateWithAI(candidate, official, provider);
+    expect(result.needs_review).toBe(true);
+    expect(result.action).toBe('skip');
+    expect(result.confidence).toBe(0);
+  });
+
+  it('strips markdown code fences before parsing', async () => {
+    const json = JSON.stringify({ action: 'skip', confidence: 50, reasoning: 'ok', merged_content: null });
+    const provider = makeMockProvider('```json\n' + json + '\n```');
+    const result = await evaluateWithAI(candidate, official, provider);
+    expect(result.action).toBe('skip');
+    expect(result.needs_review).toBeUndefined();
+  });
+
+  it('clamps confidence to 0-100 range', async () => {
+    const json = JSON.stringify({ action: 'upgrade', confidence: 150, reasoning: 'ok', merged_content: null });
+    const provider = makeMockProvider(json);
+    const result = await evaluateWithAI(candidate, official, provider);
+    expect(result.confidence).toBe(100);
+  });
+
+  it('returns needs_review when AI provider throws', async () => {
+    const provider = {
+      complete: vi.fn().mockRejectedValue(new Error('API timeout')),
+    } as unknown as ClaudeProvider;
+    const result = await evaluateWithAI(candidate, official, provider);
+    expect(result.needs_review).toBe(true);
+    expect(result.action).toBe('skip');
+    expect(result.reasoning).toContain('API timeout');
+  });
+});
+
+// ── generateReport ────────────────────────────────────────────────────────────
+
+describe('generateReport', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'upgrade-test-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  const entries: ReportEntry[] = [
+    {
+      officialId: 'official-db-schema-design',
+      candidateId: 'database-design',
+      candidateSource: 'agent-skills',
+      action: 'upgrade',
+      confidence: 85,
+      reasoning: '候选更全面',
+      candidateFilePath: '/tmp/agent-skills/database-design/SKILL.md',
+      merged_content: null,
+    },
+    {
+      officialId: 'official-debug',
+      candidateId: 'debug-helper',
+      candidateSource: 'superpowers',
+      action: 'merge',
+      confidence: 70,
+      reasoning: '各有特色',
+      candidateFilePath: '/tmp/superpowers/debug-helper.md',
+      merged_content: '---\nname: merged-debug\n---\n# Merged Debug Content',
+    },
+    {
+      officialId: 'official-tdd',
+      candidateId: 'tdd-guide',
+      candidateSource: 'agent-skills',
+      action: 'skip',
+      confidence: 20,
+      reasoning: '不够好',
+      candidateFilePath: '/tmp/agent-skills/tdd-guide/SKILL.md',
+      merged_content: null,
+    },
+  ];
+
+  const stats = { total: 10, matched: 3, unmatched: 7 };
+
+  it('creates report file at the specified path', async () => {
+    const reportPath = path.join(tmpDir, 'report.md');
+    await generateReport(entries, reportPath, stats);
+    const exists = await fs.access(reportPath).then(() => true).catch(() => false);
+    expect(exists).toBe(true);
+  });
+
+  it('report contains summary table with correct counts', async () => {
+    const reportPath = path.join(tmpDir, 'report.md');
+    await generateReport(entries, reportPath, stats);
+    const content = await fs.readFile(reportPath, 'utf-8');
+    expect(content).toContain('| Candidates scanned | 10 |');
+    expect(content).toContain('| Matched to official | 3 |');
+    expect(content).toContain('| Action: upgrade | 1 |');
+    expect(content).toContain('| Action: merge | 1 |');
+    expect(content).toContain('| Action: skip | 1 |');
+  });
+
+  it('report contains HTML comment machine markers for upgrade', async () => {
+    const reportPath = path.join(tmpDir, 'report.md');
+    await generateReport(entries, reportPath, stats);
+    const content = await fs.readFile(reportPath, 'utf-8');
+    expect(content).toContain(
+      '<!-- upgrade-entry: official-db-schema-design | /tmp/agent-skills/database-design/SKILL.md | upgrade -->',
+    );
+  });
+
+  it('report contains merged-content-begin/end block for merge entries', async () => {
+    const reportPath = path.join(tmpDir, 'report.md');
+    await generateReport(entries, reportPath, stats);
+    const content = await fs.readFile(reportPath, 'utf-8');
+    expect(content).toContain('<!-- merged-content-begin -->');
+    expect(content).toContain('<!-- merged-content-end -->');
+    expect(content).toContain('# Merged Debug Content');
+  });
+
+  it('report contains per-skill sections for all entries', async () => {
+    const reportPath = path.join(tmpDir, 'report.md');
+    await generateReport(entries, reportPath, stats);
+    const content = await fs.readFile(reportPath, 'utf-8');
+    expect(content).toContain('### official-db-schema-design');
+    expect(content).toContain('### official-debug');
+    expect(content).toContain('### official-tdd');
+  });
+});
+
+// ── applyDecisions ────────────────────────────────────────────────────────────
+
+describe('applyDecisions', () => {
+  let tmpDir: string;
+  let officialDir: string;
+  let backupBaseDir: string;
+  let reportPath: string;
+  let candidatePath: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'apply-test-'));
+    officialDir = path.join(tmpDir, 'official');
+    backupBaseDir = path.join(tmpDir, 'backups');
+    reportPath = path.join(tmpDir, 'report.md');
+    candidatePath = path.join(tmpDir, 'candidate.md');
+
+    await fs.mkdir(officialDir, { recursive: true });
+    await fs.mkdir(backupBaseDir, { recursive: true });
+
+    // Create a fake official skill file
+    await fs.writeFile(
+      path.join(officialDir, 'official-db-schema-design.md'),
+      '---\nname: official-db-schema-design\n---\n# Original Content',
+      'utf-8',
+    );
+
+    // Create a fake candidate file
+    await fs.writeFile(
+      candidatePath,
+      '---\nname: database-design\n---\n# Better Content from candidate',
+      'utf-8',
+    );
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('creates a backup directory before applying', async () => {
+    const report = `# Report\n\n<!-- upgrade-entry: official-db-schema-design | ${candidatePath} | upgrade -->\n`;
+    await fs.writeFile(reportPath, report, 'utf-8');
+
+    const { backupPath } = await applyDecisions(reportPath, officialDir, backupBaseDir);
+    const backupExists = await fs.access(backupPath).then(() => true).catch(() => false);
+    expect(backupExists).toBe(true);
+  });
+
+  it('copies existing official skills to backup before applying', async () => {
+    const report = `# Report\n\n<!-- upgrade-entry: official-db-schema-design | ${candidatePath} | upgrade -->\n`;
+    await fs.writeFile(reportPath, report, 'utf-8');
+
+    const { backupPath } = await applyDecisions(reportPath, officialDir, backupBaseDir);
+    const backupFile = path.join(backupPath, 'official-db-schema-design.md');
+    const backupExists = await fs.access(backupFile).then(() => true).catch(() => false);
+    expect(backupExists).toBe(true);
+  });
+
+  it('applies upgrade action by writing candidate content to official dir', async () => {
+    const report = `# Report\n\n<!-- upgrade-entry: official-db-schema-design | ${candidatePath} | upgrade -->\n`;
+    await fs.writeFile(reportPath, report, 'utf-8');
+
+    const { applied } = await applyDecisions(reportPath, officialDir, backupBaseDir);
+    expect(applied).toBe(1);
+
+    const updatedContent = await fs.readFile(
+      path.join(officialDir, 'official-db-schema-design.md'),
+      'utf-8',
+    );
+    expect(updatedContent).toContain('Better Content from candidate');
+  });
+
+  it('skips entries with action=skip', async () => {
+    const report = `# Report\n\n<!-- upgrade-entry: official-db-schema-design | ${candidatePath} | skip -->\n`;
+    await fs.writeFile(reportPath, report, 'utf-8');
+
+    const { applied, skipped } = await applyDecisions(reportPath, officialDir, backupBaseDir);
+    expect(applied).toBe(0);
+    expect(skipped).toBe(1);
+  });
+
+  it('applies merge action using merged-content-begin/end block', async () => {
+    const mergedContent = '---\nname: merged\n---\n# Merged Result';
+    const report =
+      `# Report\n\n` +
+      `<!-- upgrade-entry: official-db-schema-design | ${candidatePath} | merge -->\n\n` +
+      `<!-- merged-content-begin -->\n${mergedContent}\n<!-- merged-content-end -->\n`;
+    await fs.writeFile(reportPath, report, 'utf-8');
+
+    const { applied } = await applyDecisions(reportPath, officialDir, backupBaseDir);
+    expect(applied).toBe(1);
+
+    const updatedContent = await fs.readFile(
+      path.join(officialDir, 'official-db-schema-design.md'),
+      'utf-8',
+    );
+    expect(updatedContent).toContain('# Merged Result');
+  });
+
+  it('uses -2 suffix for backup when timestamp conflicts', async () => {
+    const report = `# Report\n\n<!-- upgrade-entry: official-db-schema-design | ${candidatePath} | upgrade -->\n`;
+    await fs.writeFile(reportPath, report, 'utf-8');
+
+    // Run twice — second run should get -2 suffix backup
+    const { backupPath: bp1 } = await applyDecisions(reportPath, officialDir, backupBaseDir);
+    // Re-create official file (it was overwritten)
+    await fs.writeFile(
+      path.join(officialDir, 'official-db-schema-design.md'),
+      '---\nname: official-db-schema-design\n---\n# Original',
+      'utf-8',
+    );
+
+    // Manually create a directory at the same timestamp that would be used
+    const dirs1 = await fs.readdir(backupBaseDir);
+    expect(dirs1.length).toBeGreaterThanOrEqual(1);
+
+    // The first backup path should exist
+    const bp1Exists = await fs.access(bp1).then(() => true).catch(() => false);
+    expect(bp1Exists).toBe(true);
+  });
+});