agentic-qe 3.6.1 → 3.6.3

package/scripts/migrate-validators.cjs

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+
+/**
+ * Migrate validate.sh → validate-config.json
+ *
+ * Auto-extracts configuration from existing bash validate.sh scripts
+ * and generates cross-platform validate-config.json files.
+ *
+ * Usage:
+ *   node scripts/migrate-validators.cjs              # migrate all skills
+ *   node scripts/migrate-validators.cjs --dry-run    # preview without writing
+ *   node scripts/migrate-validators.cjs --skill api-testing-patterns  # single skill
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const RESET = '\x1b[0m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+
+const args = process.argv.slice(2);
+const dryRun = args.includes('--dry-run');
+const singleSkill = args.includes('--skill') ? args[args.indexOf('--skill') + 1] : null;
+
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+const SKILLS_DIRS = [
+  path.join(PROJECT_ROOT, '.claude', 'skills'),
+  path.join(PROJECT_ROOT, 'v3', '.claude', 'skills'),
+];
+
+function extractConfig(shContent, skillDir) {
+  const config = {
+    skillName: '',
+    skillVersion: '1.0.0',
+    requiredTools: [],
+    optionalTools: [],
+    schemaPath: null,
+    requiredFields: [],
+    requiredNonEmptyFields: [],
+    mustContainTerms: [],
+    mustNotContainTerms: [],
+    enumValidations: {},
+  };
+
+  // Extract SKILL_NAME
+  const nameMatch = shContent.match(/SKILL_NAME="([^"]+)"/);
+  if (nameMatch) config.skillName = nameMatch[1];
+
+  // Extract SKILL_VERSION
+  const versionMatch = shContent.match(/SKILL_VERSION="([^"]+)"/);
+  if (versionMatch) config.skillVersion = versionMatch[1];
+
+  // Extract REQUIRED_TOOLS
+  const reqToolsMatch = shContent.match(/REQUIRED_TOOLS=\(([^)]*)\)/);
+  if (reqToolsMatch) {
+    config.requiredTools = reqToolsMatch[1].match(/"([^"]+)"/g)?.map(s => s.replace(/"/g, '')) || [];
+  }
+
+  // Extract OPTIONAL_TOOLS
+  const optToolsMatch = shContent.match(/OPTIONAL_TOOLS=\(([^)]*)\)/);
+  if (optToolsMatch) {
+    config.optionalTools = optToolsMatch[1].match(/"([^"]+)"/g)?.map(s => s.replace(/"/g, '')) || [];
+  }
+
+  // Extract SCHEMA_PATH (relative)
+  const schemaMatch = shContent.match(/SCHEMA_PATH="\$SKILL_DIR\/([^"]+)"/);
+  if (schemaMatch) config.schemaPath = schemaMatch[1];
+
+  // Extract REQUIRED_FIELDS
+  const reqFieldsMatch = shContent.match(/REQUIRED_FIELDS=\(([^)]*)\)/);
+  if (reqFieldsMatch) {
+    config.requiredFields = reqFieldsMatch[1].match(/"([^"]+)"/g)?.map(s => s.replace(/"/g, '')) || [];
+  }
+
+  // Extract REQUIRED_NON_EMPTY_FIELDS
+  const reqNonEmptyMatch = shContent.match(/REQUIRED_NON_EMPTY_FIELDS=\(([^)]*)\)/);
+  if (reqNonEmptyMatch) {
+    config.requiredNonEmptyFields = reqNonEmptyMatch[1].match(/"([^"]+)"/g)?.map(s => s.replace(/"/g, '')) || [];
+  }
+
+  // Extract MUST_CONTAIN_TERMS
+  const mustContainMatch = shContent.match(/MUST_CONTAIN_TERMS=\(([^)]*)\)/);
+  if (mustContainMatch) {
+    config.mustContainTerms = mustContainMatch[1].match(/"([^"]+)"/g)?.map(s => s.replace(/"/g, '')) || [];
+  }
+
+  // Extract MUST_NOT_CONTAIN_TERMS
+  const mustNotContainMatch = shContent.match(/MUST_NOT_CONTAIN_TERMS=\(([^)]*)\)/);
+  if (mustNotContainMatch) {
+    config.mustNotContainTerms = mustNotContainMatch[1].match(/"([^"]+)"/g)?.map(s => s.replace(/"/g, '')) || [];
+  }
+
+  // Extract ENUM_VALIDATIONS
+  const enumMatch = shContent.match(/ENUM_VALIDATIONS=\(([\s\S]*?)\)/);
+  if (enumMatch) {
+    const enumLines = enumMatch[1].match(/"([^"]+)"/g)?.map(s => s.replace(/"/g, '')) || [];
+    for (const line of enumLines) {
+      const [fieldPath, values] = line.split(':');
+      if (fieldPath && values) {
+        config.enumValidations[fieldPath] = values.split(',');
+      }
+    }
+  }
+
+  return config;
+}
+
+let migrated = 0;
+let skipped = 0;
+let failed = 0;
+
+for (const skillsDir of SKILLS_DIRS) {
+  if (!fs.existsSync(skillsDir)) continue;
+
+  const skills = fs.readdirSync(skillsDir).filter(d => {
+    if (d.startsWith('.') || d.endsWith('.json') || d.endsWith('.md')) return false;
+    if (singleSkill && d !== singleSkill) return false;
+    return fs.statSync(path.join(skillsDir, d)).isDirectory();
+  });
+
+  for (const skill of skills) {
+    const shPath = path.join(skillsDir, skill, 'scripts', 'validate.sh');
+    const configPath = path.join(skillsDir, skill, 'scripts', 'validate-config.json');
+
+    if (!fs.existsSync(shPath)) {
+      skipped++;
+      continue;
+    }
+
+    // Skip if config already exists and not in single-skill mode
+    if (fs.existsSync(configPath) && !singleSkill) {
+      console.log(`${YELLOW}[SKIP]${RESET} ${skill} — validate-config.json already exists`);
+      skipped++;
+      continue;
+    }
+
+    try {
+      const shContent = fs.readFileSync(shPath, 'utf-8');
+      const config = extractConfig(shContent, path.join(skillsDir, skill));
+
+      // Use skill directory name if SKILL_NAME not found
+      if (!config.skillName) config.skillName = skill;
+
+      if (dryRun) {
+        console.log(`${CYAN}[DRY-RUN]${RESET} ${skill}:`);
+        console.log(JSON.stringify(config, null, 2));
+        console.log('');
+      } else {
+        // Ensure scripts directory exists
+        const scriptsDir = path.join(skillsDir, skill, 'scripts');
+        if (!fs.existsSync(scriptsDir)) fs.mkdirSync(scriptsDir, { recursive: true });
+
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+        console.log(`${GREEN}[OK]${RESET} ${skill} → validate-config.json`);
+      }
+      migrated++;
+    } catch (e) {
+      console.log(`${RED}[FAIL]${RESET} ${skill}: ${e.message}`);
+      failed++;
+    }
+  }
+}
+
+console.log('');
+console.log('==============================================');
+console.log(`Migration complete: ${migrated} migrated, ${skipped} skipped, ${failed} failed`);
+if (dryRun) console.log('(dry-run mode — no files were written)');
+console.log('==============================================');

package/scripts/postinstall.cjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+/**
+ * Cross-platform postinstall script for agentic-qe
+ *
+ * Replaces the bash-only: test -f v3/package.json && cd v3 && npm install || true
+ * Works on Windows (cmd.exe, PowerShell) and Unix (bash, zsh) alike.
+ *
+ * Uses CommonJS for maximum Node.js compatibility during install.
+ */
+
+const { existsSync } = require('fs');
+const { execSync } = require('child_process');
+const { join } = require('path');
+
+const RESET = '\x1b[0m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+
+function log(msg) {
+  console.log(`${CYAN}[agentic-qe]${RESET} ${msg}`);
+}
+
+function main() {
+  const v3PackageJson = join(__dirname, '..', 'v3', 'package.json');
+
+  if (!existsSync(v3PackageJson)) {
+    // v3/package.json not present (e.g. published package without v3 source)
+    return;
+  }
+
+  const v3Dir = join(__dirname, '..', 'v3');
+
+  log('Installing v3 dependencies...');
+
+  try {
+    execSync('npm install', {
+      cwd: v3Dir,
+      stdio: 'inherit',
+      env: { ...process.env },
+    });
+    console.log(`${GREEN}[agentic-qe]${RESET} v3 dependencies installed successfully`);
+  } catch (err) {
+    // Don't fail the parent install if v3 install has issues
+    console.log(`${YELLOW}[agentic-qe]${RESET} v3 dependency install had warnings (non-blocking): ${err.message}`);
+  }
+}
+
+try {
+  main();
+} catch (err) {
+  // Never block the parent install
+  if (process.env.DEBUG) {
+    console.error(`[agentic-qe] postinstall error: ${err.message}`);
+  }
+}

package/scripts/preinstall.cjs

@@ -37,23 +37,43 @@ function success(msg) {
 }
 
 function findExistingAqeBinary() {
-  // Try 'which' command first
+  // Cross-platform binary lookup: use 'where' on Windows, 'which' elsewhere
+  const isWindows = process.platform === 'win32';
+  const lookupCmd = isWindows ? 'where' : 'which';
+
   try {
-    const result = spawnSync('which', ['aqe'], { encoding: 'utf-8' });
+    const result = spawnSync(lookupCmd, ['aqe'], {
+      encoding: 'utf-8',
+      shell: isWindows,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
     if (result.status === 0 && result.stdout.trim()) {
-      return result.stdout.trim();
+      // 'where' on Windows may return multiple lines; take the first
+      return result.stdout.trim().split(/\r?\n/)[0];
     }
   } catch {
-    // which command failed
+    // Lookup command failed
   }
 
   // Try to find via npm prefix
   try {
-    const prefix = execSync('npm config get prefix', { encoding: 'utf-8' }).trim();
-    const binPath = join(prefix, 'bin', 'aqe');
+    const prefix = execSync('npm config get prefix', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    // On Windows, global bins are in prefix directly; on Unix, prefix/bin
+    const binName = isWindows ? 'aqe.cmd' : 'aqe';
+    const binPath = isWindows ? join(prefix, binName) : join(prefix, 'bin', binName);
     if (existsSync(binPath)) {
       return binPath;
     }
+    // Also check without .cmd extension on Windows
+    if (isWindows) {
+      const altPath = join(prefix, 'aqe');
+      if (existsSync(altPath)) {
+        return altPath;
+      }
+    }
   } catch {
     // Ignore
   }
@@ -63,7 +83,7 @@ function findExistingAqeBinary() {
 
 function checkPackageInstalled(packageName) {
   try {
-    const result = execSync(`npm list -g ${packageName} --depth=0 2>/dev/null`, {
+    const result = execSync(`npm list -g ${packageName} --depth=0`, {
       encoding: 'utf-8',
       stdio: ['pipe', 'pipe', 'pipe']
     });
@@ -75,7 +95,7 @@ function checkPackageInstalled(packageName) {
 
 function getPackageVersion(packageName) {
   try {
-    const result = execSync(`npm list -g ${packageName} --depth=0 2>/dev/null`, {
+    const result = execSync(`npm list -g ${packageName} --depth=0`, {
       encoding: 'utf-8',
       stdio: ['pipe', 'pipe', 'pipe']
     });

package/scripts/test-schema-validation.js

@@ -194,7 +194,7 @@ priority: critical
 trust_tier: 3
 validation:
   schema_path: schemas/output.json
-  validator_path: scripts/validate.sh
+  validator_path: scripts/validate-config.json
   eval_path: evals/security-testing.yaml
   last_validated: 2026-02-02
   validation_status: passing
@@ -232,7 +232,7 @@ description: "A skill with trust_tier 3 but no evals"
 trust_tier: 3
 validation:
   schema_path: schemas/output.json
-  validator_path: scripts/validate.sh
+  validator_path: scripts/validate-config.json
 ---`,
     expectValid: false,
     expectedError: 'trust_tier >= 3 requires validation.eval_path'

package/scripts/update-skill-manifest.ts

@@ -267,7 +267,7 @@ function extractSkillInfo(skillDir: string, skillName: string): SkillManifestEnt
 
   // Check for validator script
   const validatorPaths = [
-    join(skillDir, 'scripts', 'validate.sh'),
+    join(skillDir, 'scripts', 'validate-config.json'),
     join(skillDir, 'scripts', 'validate.ts'),
     join(skillDir, 'scripts', 'validate.js')
   ];
@@ -531,7 +531,7 @@ To upgrade a skill to a higher trust tier:
 3. Run \`npx tsx scripts/update-skill-manifest.ts\`
 
 ### Tier 1 -> Tier 2 (Add Validator)
-1. Create \`{skill}/scripts/validate.sh\` (or .ts/.js)
+1. Create \`{skill}/scripts/validate-config.json\` (or .ts/.js)
 2. Add \`trust_tier: 2\` and validation paths to frontmatter
 3. Run \`npx tsx scripts/update-skill-manifest.ts\`
 
@@ -553,7 +553,7 @@ Add this to your GitHub Actions workflow:
 - name: Check Tier 3 Skills Pass
   run: |
     for skill in api-testing-patterns security-testing performance-testing; do
-      .claude/skills/\$skill/scripts/validate.sh --self-test
+      .claude/skills/\$skill/scripts/validate-skill.cjs --self-test
     done
 \`\`\`