agentsys 5.0.0

package/scripts/stamp-version.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+/**
+ * Version Stamp Tool
+ *
+ * Reads the version from package.json (the single source of truth)
+ * and stamps it into all downstream version files.
+ *
+ * Usage:
+ *   node scripts/stamp-version.js          # Stamp current package.json version everywhere
+ *
+ * Designed to run as an npm `version` lifecycle hook:
+ *   "version": "node scripts/stamp-version.js && git add -A"
+ *
+ * Files stamped:
+ *   - .claude-plugin/plugin.json
+ *   - .claude-plugin/marketplace.json (all version occurrences)
+ *   - plugins/*\/.claude-plugin/plugin.json (discovered via lib/discovery)
+ *   - site/content.json (meta.version)
+ *   - plugins/*\/skills/*\/SKILL.md (version in YAML frontmatter)
+ *
+ * @author Avi Fenesh
+ * @license MIT
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT_DIR = path.resolve(__dirname, '..');
+
+/**
+ * Update the "version" field in a JSON file.
+ *
+ * @param {string} filePath - Absolute or relative path to the JSON file
+ * @param {string} version - Version string to set
+ * @returns {boolean} true if file was updated, false if skipped
+ */
+function updateJsonFile(filePath, version) {
+  const absPath = path.isAbsolute(filePath) ? filePath : path.join(ROOT_DIR, filePath);
+  if (!fs.existsSync(absPath)) {
+    console.log(`  [SKIP] ${filePath} (not found)`);
+    return false;
+  }
+
+  const content = JSON.parse(fs.readFileSync(absPath, 'utf8'));
+  const oldVersion = content.version;
+  content.version = version;
+  fs.writeFileSync(absPath, JSON.stringify(content, null, 2) + '\n');
+  console.log(`  [OK] ${filePath}: ${oldVersion} -> ${version}`);
+  return true;
+}
+
+/**
+ * Update all "version" occurrences in marketplace.json via regex.
+ *
+ * @param {string} filePath - Path to marketplace.json
+ * @param {string} version - Version string to set
+ * @returns {boolean} true if file was updated, false if skipped
+ */
+function updateMarketplaceJson(filePath, version) {
+  const absPath = path.isAbsolute(filePath) ? filePath : path.join(ROOT_DIR, filePath);
+  if (!fs.existsSync(absPath)) {
+    console.log(`  [SKIP] ${filePath} (not found)`);
+    return false;
+  }
+
+  let content = fs.readFileSync(absPath, 'utf8');
+  const oldVersionMatch = content.match(/"version":\s*"([^"]+)"/);
+  const oldVersion = oldVersionMatch ? oldVersionMatch[1] : 'unknown';
+
+  // Replace all version occurrences
+  content = content.replace(/"version":\s*"[^"]+"/g, `"version": "${version}"`);
+  fs.writeFileSync(absPath, content);
+
+  const count = (content.match(/"version":/g) || []).length;
+  console.log(`  [OK] ${filePath}: ${oldVersion} -> ${version} (${count} occurrences)`);
+  return true;
+}
+
+/**
+ * Update the meta.version field in site/content.json.
+ * Uses regex replacement to preserve original formatting.
+ *
+ * @param {string} filePath - Path to content.json
+ * @param {string} version - Version string to set
+ * @returns {boolean} true if file was updated, false if skipped
+ */
+function updateContentJson(filePath, version) {
+  const absPath = path.isAbsolute(filePath) ? filePath : path.join(ROOT_DIR, filePath);
+  if (!fs.existsSync(absPath)) {
+    console.log(`  [SKIP] ${filePath} (not found)`);
+    return false;
+  }
+
+  let content = fs.readFileSync(absPath, 'utf8');
+  const oldVersionMatch = content.match(/"version":\s*"([^"]+)"/);
+  const oldVersion = oldVersionMatch ? oldVersionMatch[1] : 'unknown';
+
+  // Replace only the first "version" occurrence (inside meta block)
+  content = content.replace(/"version":\s*"[^"]+"/,  `"version": "${version}"`);
+  fs.writeFileSync(absPath, content);
+  console.log(`  [OK] ${filePath}: ${oldVersion} -> ${version}`);
+  return true;
+}
+
+/**
+ * Stamp the version from package.json into all downstream files.
+ *
+ * @param {string} [rootDir] - Repository root. Defaults to parent of scripts/.
+ * @returns {number} 0 on success, 1 on error
+ */
+function stampVersion(rootDir) {
+  if (!rootDir) rootDir = ROOT_DIR;
+
+  const pkgPath = path.join(rootDir, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    console.error('[ERROR] package.json not found');
+    return 1;
+  }
+
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+  const version = pkg.version;
+
+  console.log(`\nStamping version: ${version}\n`);
+
+  // Root plugin.json
+  console.log('Root plugin:');
+  updateJsonFile(path.join(rootDir, '.claude-plugin', 'plugin.json'), version);
+
+  // Marketplace
+  console.log('\nMarketplace:');
+  updateMarketplaceJson(path.join(rootDir, '.claude-plugin', 'marketplace.json'), version);
+
+  // Plugin plugin.json files (discovered from filesystem)
+  console.log('\nPlugins:');
+  const discovery = require(path.join(rootDir, 'lib', 'discovery'));
+  const pluginNames = discovery.discoverPlugins(rootDir);
+  for (const plugin of pluginNames) {
+    const pluginPath = path.join(rootDir, 'plugins', plugin, '.claude-plugin', 'plugin.json');
+    updateJsonFile(pluginPath, version);
+  }
+
+  // Site content.json
+  console.log('\nSite:');
+  updateContentJson(path.join(rootDir, 'site', 'content.json'), version);
+
+  // Skill SKILL.md files (version in YAML frontmatter)
+  console.log('\nSkills:');
+  let skillCount = 0;
+  for (const plugin of pluginNames) {
+    const skillsDir = path.join(rootDir, 'plugins', plugin, 'skills');
+    if (!fs.existsSync(skillsDir)) continue;
+    const skillDirs = fs.readdirSync(skillsDir, { withFileTypes: true }).filter(d => d.isDirectory());
+    for (const skillDir of skillDirs) {
+      const skillMdPath = path.join(skillsDir, skillDir.name, 'SKILL.md');
+      if (!fs.existsSync(skillMdPath)) continue;
+      let content = fs.readFileSync(skillMdPath, 'utf8');
+      const updated = content.replace(/^(version:\s*)\S+/m, `$1${version}`);
+      if (updated !== content) {
+        fs.writeFileSync(skillMdPath, updated);
+        skillCount++;
+      }
+    }
+  }
+  console.log(`  [OK] ${skillCount} SKILL.md file(s) stamped`);
+
+  console.log(`\n[OK] Version ${version} stamped to all files\n`);
+  return 0;
+}
+
+if (require.main === module) {
+  const code = stampVersion();
+  if (typeof code === 'number') process.exit(code);
+}
+
+module.exports = { stampVersion, updateJsonFile, updateMarketplaceJson, updateContentJson };

package/scripts/test-transform.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+
+function main() {
+  // Read the source file
+  const content = fs.readFileSync(path.join(__dirname, '..', 'plugins', 'next-task', 'commands', 'next-task.md'), 'utf8');
+
+  // Apply transformation (same as installer)
+  let transformed = content;
+
+  // Transform code blocks
+  transformed = transformed.replace(
+    /```(\w*)\n([\s\S]*?)```/g,
+    (match, lang, code) => {
+      const langLower = (lang || '').toLowerCase();
+
+      // Keep bash
+      if (langLower === 'bash' || langLower === 'shell') {
+        if (code.includes('node -e') && code.includes('require(')) {
+          return '*(Bash with Node.js require - adapt for OpenCode)*';
+        }
+        return match;
+      }
+
+      // Keep simple bash-like commands
+      if (!lang && (code.trim().startsWith('gh ') || code.trim().startsWith('git '))) {
+        return match;
+      }
+
+      // Transform JS
+      if (code.includes('require(') || code.includes('Task(') ||
+          code.includes('const ') || code.includes('async ')) {
+        let instructions = '';
+        const taskMatches = [...code.matchAll(/Task\s*\(\s*\{[^}]*subagent_type:\s*["'](?:[^"':]+:)?([^"']+)["']/gs)];
+        for (const tm of taskMatches) {
+          instructions += '- Invoke `@' + tm[1] + '` agent\n';
+        }
+        if (code.includes('workflowState.startPhase')) {
+          const pm = code.match(/startPhase\s*\(\s*['"]([^'"]+)['"]/);
+          if (pm) instructions += '- Phase: ' + pm[1] + '\n';
+        }
+        if (instructions) return instructions;
+        return '*(JS reference - not executable)*';
+      }
+      return match;
+    }
+  );
+
+  // Remove remaining patterns outside code blocks
+  transformed = transformed.replace(/await\s+Task\s*\(\s*\{[\s\S]*?\}\s*\);?/g, (match) => {
+    const agentMatch = match.match(/subagent_type:\s*["'](?:[^"':]+:)?([^"']+)["']/);
+    if (agentMatch) return 'Invoke `@' + agentMatch[1] + '` agent';
+    return '*(Task call - use @agent syntax)*';
+  });
+
+  transformed = transformed.replace(/(?:const|let|var)\s+\{?[^}=\n]+\}?\s*=\s*require\s*\([^)]+\);?/g, '');
+  transformed = transformed.replace(/require\s*\(['"][^'"]+['"]\)/g, '');
+
+  // Check for remaining patterns
+  const hasRequire = transformed.match(/require\s*\(/g);
+  const hasTask = transformed.match(/await\s+Task\s*\(/g);
+
+  console.log('Has require():', hasRequire ? hasRequire.length : 0);
+  console.log('Has await Task():', hasTask ? hasTask.length : 0);
+  console.log('');
+
+  // Show a section with transformation
+  const lines = transformed.split('\n');
+  let inPhase2 = false;
+  for (let i = 0; i < lines.length && i < 250; i++) {
+    if (lines[i].includes('Phase 2')) inPhase2 = true;
+    if (inPhase2 && i < 220) console.log(lines[i]);
+    if (lines[i].includes('Phase 3') && inPhase2) break;
+  }
+
+  return 0;
+}
+
+if (require.main === module) {
+  const code = main();
+  if (typeof code === 'number') process.exit(code);
+}
+
+module.exports = { main };

package/scripts/validate-agent-skill-compliance.js

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+/**
+ * Validate Agent Skills Open Standard Compliance
+ *
+ * Checks:
+ * 1. Agents that invoke skills have `Skill` tool in frontmatter
+ * 2. Skill directory names match skill names in SKILL.md frontmatter
+ * 3. Skill names follow the standard (lowercase, hyphens, max 64 chars)
+ *
+ * Exit codes:
+ * 0 - All checks pass
+ * 1 - Violations found
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const pluginsDir = path.join(__dirname, '..', 'plugins');
+
+/**
+ * Parse frontmatter from markdown content
+ * Handles both single-line and YAML list formats for tools
+ */
+function parseFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) return null;
+
+  const frontmatter = {};
+  const lines = frontmatterMatch[1].split('\n');
+  let currentKey = null;
+  let collectingList = false;
+  let listItems = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Check if this is a list item (starts with whitespace and -)
+    if (collectingList && /^\s+-\s/.test(line)) {
+      const item = line.replace(/^\s+-\s*/, '').trim();
+      listItems.push(item);
+      continue;
+    }
+
+    // If we were collecting a list and hit a non-list line, save the list
+    if (collectingList) {
+      frontmatter[currentKey] = listItems.join(', ');
+      collectingList = false;
+      listItems = [];
+    }
+
+    const colonIndex = line.indexOf(':');
+    if (colonIndex === -1) continue;
+
+    const key = line.substring(0, colonIndex).trim();
+    let value = line.substring(colonIndex + 1).trim();
+
+    // Check if this starts a YAML list
+    if (value === '' && i + 1 < lines.length && /^\s+-\s/.test(lines[i + 1])) {
+      currentKey = key;
+      collectingList = true;
+      listItems = [];
+      continue;
+    }
+
+    // Remove quotes if present
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+
+    frontmatter[key] = value;
+  }
+
+  if (collectingList) {
+    frontmatter[currentKey] = listItems.join(', ');
+  }
+
+  return frontmatter;
+}
+
+/**
+ * Check if agent content indicates it needs to invoke a skill
+ */
+function detectSkillInvocationRequirement(content) {
+  const patterns = [
+    /MUST execute the [`']?([a-z0-9-]+)[`']? skill/gi,
+    /MUST invoke the [`']?([a-z0-9-]+)[`']? skill/gi,
+    /execute the [`']?([a-z0-9-]+)[`']? skill/gi,
+    /invoke the [`']?([a-z0-9-]+)[`']? skill/gi,
+    /You MUST execute the.*skill/gi,
+    /You MUST invoke the.*skill/gi,
+    /MUST execute.*skill to/gi,
+    /Do not bypass the skill/gi,
+    /Invoke your skill/gi
+  ];
+
+  const evidence = [];
+  for (const pattern of patterns) {
+    const matches = content.match(pattern);
+    if (matches) {
+      evidence.push(...matches);
+    }
+  }
+
+  return {
+    needsSkill: evidence.length > 0,
+    evidence: [...new Set(evidence)]
+  };
+}
+
+/**
+ * Check if tools list includes Skill
+ */
+function hasSkillTool(toolsString) {
+  if (!toolsString) return false;
+  const tools = toolsString.split(/[,\s]+/).map(t => t.trim());
+  return tools.some(t => t === 'Skill' || t.startsWith('Skill,') || t.endsWith(',Skill'));
+}
+
+/**
+ * Get all agent files from all plugins
+ */
+function getAllAgentFiles() {
+  const agents = [];
+  const plugins = fs.readdirSync(pluginsDir).filter(f =>
+    fs.statSync(path.join(pluginsDir, f)).isDirectory()
+  );
+
+  for (const plugin of plugins) {
+    const agentsDir = path.join(pluginsDir, plugin, 'agents');
+    if (fs.existsSync(agentsDir)) {
+      const files = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+      for (const file of files) {
+        agents.push({
+          plugin,
+          file,
+          path: path.join(agentsDir, file)
+        });
+      }
+    }
+  }
+
+  return agents;
+}
+
+/**
+ * Get all skill directories from all plugins
+ */
+function getAllSkillDirs() {
+  const skills = [];
+  const plugins = fs.readdirSync(pluginsDir).filter(f =>
+    fs.statSync(path.join(pluginsDir, f)).isDirectory()
+  );
+
+  for (const plugin of plugins) {
+    const skillsDir = path.join(pluginsDir, plugin, 'skills');
+    if (fs.existsSync(skillsDir)) {
+      const dirs = fs.readdirSync(skillsDir).filter(f => {
+        const fullPath = path.join(skillsDir, f);
+        return fs.statSync(fullPath).isDirectory() &&
+               fs.existsSync(path.join(fullPath, 'SKILL.md'));
+      });
+
+      for (const dirName of dirs) {
+        skills.push({
+          plugin,
+          dirName,
+          skillPath: path.join(skillsDir, dirName, 'SKILL.md')
+        });
+      }
+    }
+  }
+
+  return skills;
+}
+
+function main() {
+  const issues = [];
+
+  console.log('Validating Agent Skills Open Standard Compliance...\n');
+
+  // Check 1: Agents invoking skills have Skill tool
+  console.log('[1/3] Checking agents have Skill tool when needed...');
+  const agents = getAllAgentFiles();
+
+  for (const { plugin, file, path: agentPath } of agents) {
+    const content = fs.readFileSync(agentPath, 'utf8');
+    const frontmatter = parseFrontmatter(content);
+    const { needsSkill, evidence } = detectSkillInvocationRequirement(content);
+
+    if (needsSkill && (!frontmatter || !hasSkillTool(frontmatter.tools))) {
+      issues.push({
+        type: 'missing-skill-tool',
+        file: `${plugin}/agents/${file}`,
+        message: `Agent invokes skill but lacks Skill tool: "${evidence[0]}"`,
+        fix: `Add 'Skill' to the tools field in frontmatter`
+      });
+    }
+  }
+
+  // Check 2: Skill directories match skill names
+  console.log('[2/3] Checking skill directory names match skill names...');
+  const skills = getAllSkillDirs();
+
+  for (const { plugin, dirName, skillPath } of skills) {
+    const content = fs.readFileSync(skillPath, 'utf8');
+    const frontmatter = parseFrontmatter(content);
+
+    if (!frontmatter || !frontmatter.name) {
+      issues.push({
+        type: 'missing-skill-name',
+        file: `${plugin}/skills/${dirName}/SKILL.md`,
+        message: `Skill is missing required 'name' field`,
+        fix: `Add 'name: ${dirName}' to SKILL.md frontmatter`
+      });
+      continue;
+    }
+
+    if (frontmatter.name !== dirName) {
+      issues.push({
+        type: 'name-mismatch',
+        file: `${plugin}/skills/${dirName}`,
+        message: `Directory '${dirName}' doesn't match skill name '${frontmatter.name}'`,
+        fix: `Rename directory to '${frontmatter.name}' or update name in SKILL.md`
+      });
+    }
+
+    // Check 3: Skill name format
+    if (!/^[a-z0-9-]+$/.test(frontmatter.name)) {
+      issues.push({
+        type: 'invalid-name-format',
+        file: `${plugin}/skills/${dirName}/SKILL.md`,
+        message: `Skill name '${frontmatter.name}' contains invalid characters`,
+        fix: `Use only lowercase letters, numbers, and hyphens`
+      });
+    }
+
+    if (frontmatter.name.length > 64) {
+      issues.push({
+        type: 'name-too-long',
+        file: `${plugin}/skills/${dirName}/SKILL.md`,
+        message: `Skill name exceeds 64 character limit (${frontmatter.name.length} chars)`,
+        fix: `Shorten the skill name to 64 characters or less`
+      });
+    }
+
+    if (!frontmatter.description) {
+      issues.push({
+        type: 'missing-description',
+        file: `${plugin}/skills/${dirName}/SKILL.md`,
+        message: `Skill is missing required 'description' field`,
+        fix: `Add description explaining WHAT the skill does and WHEN to use it`
+      });
+    }
+  }
+
+  console.log('[3/3] Generating report...\n');
+
+  // Report results
+  if (issues.length === 0) {
+    console.log('[OK] Agent Skills Open Standard Compliance');
+    console.log(`     Checked ${agents.length} agents, ${skills.length} skills`);
+    console.log('     All checks passed!\n');
+    return 0;
+  }
+
+  console.log(`[ERROR] Found ${issues.length} compliance issue(s):\n`);
+
+  for (const issue of issues) {
+    console.log(`  - ${issue.file}`);
+    console.log(`    ${issue.message}`);
+    console.log(`    Fix: ${issue.fix}\n`);
+  }
+
+  console.log('See: checklists/new-skill.md for Agent Skills Open Standard requirements\n');
+  return 1;
+}
+
+if (require.main === module) {
+  const code = main();
+  if (typeof code === 'number') process.exit(code);
+}
+
+module.exports = { main };