agentic-qe 3.6.19 → 3.7.1

package/scripts/generate-opencode-skills.ts

@@ -0,0 +1,318 @@
+/**
+ * generate-opencode-skills.ts
+ *
+ * Reads all .claude/skills/SKILL.md files and generates .opencode/skills/{name}.yaml
+ * configs for the OpenCode platform.
+ *
+ * Usage: npx tsx scripts/generate-opencode-skills.ts
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface SkillFrontmatter {
+  name: string;
+  description: string;
+  domain?: string;
+  category?: string;
+  trust_tier: number;
+  tags?: string[];
+}
+
+interface SkillStep {
+  name: string;
+  description: string;
+  tools: string[];
+  prompt: string;
+}
+
+interface SkillConfig {
+  name: string;
+  description: string;
+  minModelTier: string;
+  tags: string[];
+  steps: SkillStep[];
+}
+
+// Platform infrastructure skills to exclude
+const EXCLUDED_PREFIXES = [
+  'v3-',
+  'flow-nexus-',
+  'agentdb-',
+  'reasoningbank-',
+  'swarm-',
+  'hive-mind-',
+  'hooks-',
+];
+
+function tierToMinModel(tier: number): string {
+  switch (tier) {
+    case 0:
+    case 1:
+      return 'tier1-fast';
+    case 2:
+      return 'tier2-good';
+    case 3:
+      return 'tier3-best';
+    default:
+      return 'tier2-good';
+  }
+}
+
+function parseFrontmatter(content: string): SkillFrontmatter | null {
+  // Normalize CRLF to LF before parsing
+  const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  const match = normalized.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+
+  const yaml = match[1];
+  const result: Record<string, unknown> = {};
+
+  for (const line of yaml.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    // Skip nested YAML keys (indented lines that are part of objects)
+    if (line.startsWith('  ') && !line.trim().startsWith('-')) continue;
+
+    const colonIdx = trimmed.indexOf(':');
+    if (colonIdx === -1) continue;
+
+    const key = trimmed.slice(0, colonIdx).trim();
+    let value = trimmed.slice(colonIdx + 1).trim();
+
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+
+    if (value.startsWith('[') && value.endsWith(']')) {
+      result[key] = value
+        .slice(1, -1)
+        .split(',')
+        .map((s: string) => s.trim().replace(/['"]/g, ''))
+        .filter(Boolean);
+    } else if (key === 'trust_tier') {
+      result[key] = parseInt(value, 10);
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result as unknown as SkillFrontmatter;
+}
+
+/**
+ * Extract phases/steps from markdown headers (## and ### sections)
+ */
+function extractSteps(content: string): SkillStep[] {
+  const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  const afterFrontmatter = normalized.replace(/^---[\s\S]*?---\n*/, '');
+  const steps: SkillStep[] = [];
+
+  // Find all ## and ### Phase/Step headers
+  const phaseRegex = /^#{2,3}\s+(?:Phase\s+\d+\s*[-—:]\s*)?(?:Step\s+\d+\s*[-—:]\s*)?(.+)/gm;
+  const sections: Array<{ title: string; start: number }> = [];
+
+  let match: RegExpExecArray | null;
+  while ((match = phaseRegex.exec(afterFrontmatter)) !== null) {
+    sections.push({
+      title: match[1].trim(),
+      start: match.index,
+    });
+  }
+
+  // Skip certain headers that are not actual steps
+  const skipHeaders = [
+    'quick reference card',
+    'when to use',
+    'agent coordination',
+    'fleet coordination',
+    'memory namespace',
+    'related skills',
+    'remember',
+    'common mistakes',
+    'common pitfalls',
+    'anti-patterns',
+    'tools',
+    'purpose',
+    'activation',
+    'quick start',
+    'prerequisites',
+    'see also',
+    'references',
+  ];
+
+  for (let i = 0; i < sections.length && steps.length < 8; i++) {
+    const section = sections[i];
+    const titleLower = section.title.toLowerCase();
+
+    if (skipHeaders.some((skip) => titleLower.includes(skip))) continue;
+
+    const end = i + 1 < sections.length ? sections[i + 1].start : afterFrontmatter.length;
+    const body = afterFrontmatter.slice(section.start, end);
+
+    // Extract first meaningful paragraph as description
+    const lines = body.split('\n').slice(1);
+    const descLines: string[] = [];
+    for (const line of lines) {
+      const t = line.trim();
+      if (t === '' && descLines.length > 0) break;
+      if (t.startsWith('#') || t.startsWith('```') || t.startsWith('|') || t.startsWith('<')) break;
+      if (t !== '') descLines.push(t);
+    }
+
+    const description = descLines.join(' ').slice(0, 300) || section.title;
+    const stepName = section.title
+      .toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, '')
+      .replace(/\s+/g, '-')
+      .slice(0, 40);
+
+    // Determine tools from step content
+    const tools: string[] = ['bash', 'read'];
+    const bodyLower = body.toLowerCase();
+    if (bodyLower.includes('edit') || bodyLower.includes('fix') || bodyLower.includes('change') || bodyLower.includes('modify')) {
+      tools.push('edit');
+    }
+    if (bodyLower.includes('grep') || bodyLower.includes('search') || bodyLower.includes('find')) {
+      tools.push('grep');
+    }
+    if (bodyLower.includes('mcp') || bodyLower.includes('memory') || bodyLower.includes('agentic-qe')) {
+      tools.push('mcp:agentic-qe:*');
+    }
+
+    steps.push({
+      name: stepName,
+      description,
+      tools,
+      prompt: description,
+    });
+  }
+
+  // If no steps extracted, create a single generic step
+  if (steps.length === 0) {
+    steps.push({
+      name: 'execute',
+      description: 'Execute the skill workflow',
+      tools: ['bash', 'read', 'edit', 'grep'],
+      prompt: 'Execute the skill workflow as described in the skill documentation.',
+    });
+  }
+
+  return steps;
+}
+
+function escapeYamlString(s: string): string {
+  return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function generateSkillYaml(config: SkillConfig): string {
+  const tagsList = config.tags.map((t) => `"${escapeYamlString(t)}"`).join(', ');
+
+  let yaml = `name: ${config.name}
+description: "${escapeYamlString(config.description)}"
+minModelTier: ${config.minModelTier}
+tags: [${tagsList}]
+steps:
+`;
+
+  for (const step of config.steps) {
+    const toolsList = step.tools.map((t) => `"${t}"`).join(', ');
+    yaml += `  - name: ${step.name}
+    description: "${escapeYamlString(step.description)}"
+    tools: [${toolsList}]
+    prompt: |
+      ${step.prompt.replace(/\n/g, '\n      ')}
+`;
+  }
+
+  return yaml;
+}
+
+function isExcluded(name: string): boolean {
+  return EXCLUDED_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+
+/** Compute the output name, avoiding double qe- prefix */
+function computeOutputName(dirName: string): string {
+  const safeName = dirName.replace(/[^a-z0-9-]/g, '-');
+  // If directory already starts with qe- or qcsd-, don't add qe- prefix
+  if (safeName.startsWith('qe-') || safeName.startsWith('qcsd-')) {
+    return safeName;
+  }
+  return `qe-${safeName}`;
+}
+
+async function main(): Promise<void> {
+  const skillsDir = path.resolve(__dirname, '../.claude/skills');
+  const outputDir = path.resolve(__dirname, '../.opencode/skills');
+
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  // Clear existing generated skills
+  for (const existing of fs.readdirSync(outputDir)) {
+    if (existing.endsWith('.yaml')) {
+      fs.unlinkSync(path.join(outputDir, existing));
+    }
+  }
+
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  let generated = 0;
+  let skipped = 0;
+  const skippedNames: string[] = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (isExcluded(entry.name)) {
+      skipped++;
+      continue;
+    }
+
+    const skillPath = path.join(skillsDir, entry.name, 'SKILL.md');
+    if (!fs.existsSync(skillPath)) {
+      skippedNames.push(`${entry.name} (no SKILL.md)`);
+      skipped++;
+      continue;
+    }
+
+    const content = fs.readFileSync(skillPath, 'utf-8');
+    const frontmatter = parseFrontmatter(content);
+    if (!frontmatter || !frontmatter.name) {
+      skippedNames.push(`${entry.name} (no frontmatter/name)`);
+      skipped++;
+      continue;
+    }
+
+    const outputName = computeOutputName(entry.name);
+    const tags = [...(frontmatter.tags ?? []), 'qe', 'quality-engineering'];
+    if (frontmatter.category) tags.push(frontmatter.category);
+    if (frontmatter.domain) tags.push(frontmatter.domain);
+
+    const steps = extractSteps(content);
+    const minModelTier = tierToMinModel(frontmatter.trust_tier ?? 2);
+
+    const config: SkillConfig = {
+      name: outputName,
+      description: (frontmatter.description || frontmatter.name).slice(0, 300),
+      minModelTier,
+      tags: [...new Set(tags)],
+      steps,
+    };
+
+    const yaml = generateSkillYaml(config);
+    const outputPath = path.join(outputDir, `${outputName}.yaml`);
+    fs.writeFileSync(outputPath, yaml, 'utf-8');
+    generated++;
+  }
+
+  console.log(`Skill generation complete: ${generated} generated, ${skipped} skipped`);
+  if (skippedNames.length > 0) {
+    console.log(`Skipped details: ${skippedNames.join(', ')}`);
+  }
+  console.log(`Output directory: ${outputDir}`);
+}
+
+main().catch((err) => {
+  console.error('Generation failed:', err);
+  process.exit(1);
+});