agentsys 5.4.1 → 5.6.4

package/lib/discovery/index.js

@@ -163,14 +163,11 @@ function discoverCommands(repoRoot) {
 
     const files = fs.readdirSync(commandsDir).filter(f => f.endsWith('.md')).sort();
     for (const file of files) {
-      const baseName = file.replace(/\.md$/, '');
-      // Validate filename contains only safe characters (no path traversal)
-      if (!/^[a-zA-Z0-9_-]+$/.test(baseName)) continue;
       const filePath = path.join(commandsDir, file);
       const content = fs.readFileSync(filePath, 'utf8');
       const frontmatter = parseFrontmatter(content);
       commands.push({
-        name: baseName,
+        name: file.replace(/\.md$/, ''),
         plugin,
         file,
         frontmatter
@@ -340,48 +337,6 @@ function invalidateCache() {
   _cacheRoot = null;
 }
 
-/**
- * Build Cursor rule mappings from discovered commands.
- * Returns [ruleName, pluginName, sourceFile, description, type, globs] tuples.
- * Uses cursor-description frontmatter field, falls back to codex-description, then description.
- *
- * @param {string} [repoRoot] - Repository root path
- * @returns {Array<[string, string, string, string, string, string]>}
- */
-function getCursorRuleMappings(repoRoot) {
-  const commands = discoverCommands(repoRoot);
-  return commands.map(cmd => {
-    const description = cmd.frontmatter['cursor-description'] ||
-                        cmd.frontmatter['codex-description'] ||
-                        cmd.frontmatter.description ||
-                        '';
-    const type = cmd.frontmatter.type || 'command';
-    const globs = cmd.frontmatter.globs || '';
-    return [`agentsys-${cmd.plugin}-${cmd.name}`, cmd.plugin, cmd.file, description, type, globs];
-  });
-}
-
-/**
- * Build Kiro steering mappings from discovered commands.
- * Returns [steeringName, pluginName, sourceFile, description] tuples.
- * Uses kiro-description frontmatter field, falls back to cursor-description,
- * codex-description, then description.
- *
- * @param {string} [repoRoot] - Repository root path
- * @returns {Array<[string, string, string, string]>}
- */
-function getKiroSteeringMappings(repoRoot) {
-  const commands = discoverCommands(repoRoot);
-  return commands.map(cmd => {
-    const description = cmd.frontmatter['kiro-description'] ||
-                        cmd.frontmatter['cursor-description'] ||
-                        cmd.frontmatter['codex-description'] ||
-                        cmd.frontmatter.description ||
-                        '';
-    return [cmd.name, cmd.plugin, cmd.file, description];
-  });
-}
-
 module.exports = {
   parseFrontmatter,
   isValidPluginName,
@@ -392,8 +347,6 @@ module.exports = {
   discoverAll,
   getCommandMappings,
   getCodexSkillMappings,
-  getCursorRuleMappings,
-  getKiroSteeringMappings,
   getPluginPrefixRegex,
   invalidateCache
 };

package/lib/index.js

@@ -29,6 +29,7 @@ const repoMap = require('./repo-map');
 const perf = require('./perf');
 const collectors = require('./collectors');
 const discoveryModule = require('./discovery');
+const binary = require('./binary');
 
 /**
  * Platform detection and verification utilities
@@ -253,6 +254,7 @@ module.exports = {
   perf,
   collectors,
   discovery,
+  binary,
 
   // Direct module access for backward compatibility
   detectPlatform,

package/lib/patterns/cli-enhancers.js

@@ -13,7 +13,6 @@
  */
 
 const { execSync, execFileSync } = require('child_process');
-const os = require('os');
 const path = require('path');
 const fs = require('fs');
 // Note: escapeDoubleQuotes no longer needed - using execFileSync with arg arrays
@@ -346,20 +345,16 @@ function runDuplicateDetection(repoPath, options = {}) {
   const minLines = options.minLines || 5;
   const minTokens = options.minTokens || 50;
 
-  // Use temp directory for jscpd output to avoid platform-specific null device issues.
-  // On Windows, NUL passed via execFileSync (no shell) is treated as a literal filename,
-  // creating a mangled path in the working directory.
-  let tempOutputDir;
   try {
-    tempOutputDir = fs.mkdtempSync(path.join(os.tmpdir(), 'jscpd-'));
     // Run jscpd with JSON output
     // Use execFileSync with arg array to prevent command injection (no shell interpretation)
+    const outputPath = process.platform === 'win32' ? 'NUL' : '/dev/null';
     const args = [
       repoPath,
       '--min-lines', String(minLines),
       '--min-tokens', String(minTokens),
       '--reporters', 'json',
-      '--output', tempOutputDir,
+      '--output', outputPath,
       '--silent'
     ];
 
@@ -398,10 +393,6 @@ function runDuplicateDetection(repoPath, options = {}) {
   } catch {
     // Tool execution failed
     return null;
-  } finally {
-    if (tempOutputDir) {
-      try { fs.rmSync(tempOutputDir, { recursive: true, force: true }); } catch {}
-    }
   }
 }
 

package/lib/platform/state-dir.js

@@ -32,12 +32,10 @@ function isDirectory(targetPath) {
  * 1. AI_STATE_DIR env var (user override)
  * 2. OpenCode detection (OPENCODE_CONFIG env or .opencode/ exists)
  * 3. Codex detection (CODEX_HOME env or .codex/ exists)
- * 4. Kiro detection (.kiro/ exists)
- * 5. Cursor detection (.cursor/ exists)
- * 6. Default to .claude (Claude Code or unknown)
+ * 4. Default to .claude (Claude Code or unknown)
  *
  * @param {string} [basePath=process.cwd()] - Base path to check for project directories
- * @returns {string} State directory name (e.g., '.claude', '.opencode', '.codex', '.kiro')
+ * @returns {string} State directory name (e.g., '.claude', '.opencode', '.codex')
  */
 function getStateDir(basePath = process.cwd()) {
   // Check user override first
@@ -85,17 +83,6 @@ function getStateDir(basePath = process.cwd()) {
     // Ignore errors, continue detection
   }
 
-  // Kiro detection
-  try {
-    const kiroPath = path.join(basePath, '.kiro');
-    if (isDirectory(kiroPath)) {
-      _cachedStateDirs.set(cacheKey, '.kiro');
-      return '.kiro';
-    }
-  } catch {
-    // Ignore errors, continue detection
-  }
-
   // Default to Claude Code
   _cachedStateDirs.set(cacheKey, '.claude');
   return '.claude';
@@ -125,7 +112,6 @@ function getPlatformName(basePath = process.cwd()) {
   switch (stateDir) {
     case '.opencode': return 'opencode';
     case '.codex': return 'codex';
-    case '.kiro': return 'kiro';
     case '.claude': return 'claude';
     default: return 'unknown';
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentsys",
-  "version": "5.4.1",
+  "version": "5.6.4",
   "description": "A modular runtime and orchestration system for AI agents - works with Claude Code, OpenCode, and Codex CLI",
   "main": "lib/platform/detect-platform.js",
   "type": "commonjs",

package/scripts/gen-adapters.js

@@ -120,11 +120,13 @@ function computeAdapters() {
     process.exit(1);
   }
 
-  // --- Kiro adapters ---
+  // --- Kiro adapters (disabled - Kiro adapter generation removed) ---
   const KIRO_PLUGIN_ROOT_PLACEHOLDER = '{{PLUGIN_INSTALL_PATH}}';
 
   // Kiro steering files (from commands)
-  const kiroSteeringMappings = discovery.getKiroSteeringMappings(ROOT_DIR);
+  const kiroSteeringMappings = typeof discovery.getKiroSteeringMappings === 'function'
+    ? discovery.getKiroSteeringMappings(ROOT_DIR)
+    : [];
   for (const [steeringName, plugin, sourceFile, description] of kiroSteeringMappings) {
     const srcPath = path.join(ROOT_DIR, 'plugins', plugin, 'commands', sourceFile);
     if (!fs.existsSync(srcPath)) continue;

package/scripts/generate-docs.js

@@ -53,12 +53,62 @@ const CATEGORY_MAP = {
   'sync-docs': 'Cleanup',
   'drift-detect': 'Analysis',
   'repo-map': 'Analysis',
-  'learn': 'Learning',
+  'learn': 'AI Collaboration',
   'agnix': 'Linting',
-  'consult': 'Productivity',
-  'debate': 'Analysis'
+  'consult': 'AI Collaboration',
+  'debate': 'AI Collaboration',
+  'skillers': 'AI Collaboration',
+  'web-ctl': 'Web',
+  'ship': 'Release',
+  'git-map': 'Analysis',
+  'onboard': 'Onboarding',
+  'can-i-help': 'Onboarding',
+  'audit-project': 'Code Review'
 };
 
+// Static skill definitions for cross-repo plugins (not discoverable locally)
+const STATIC_SKILLS = [
+  { plugin: 'next-task', name: 'orchestrate-review' },
+  { plugin: 'next-task', name: 'discover-tasks' },
+  { plugin: 'next-task', name: 'validate-delivery' },
+  { plugin: 'enhance', name: 'enhance-orchestrator' },
+  { plugin: 'enhance', name: 'enhance-plugins' },
+  { plugin: 'enhance', name: 'enhance-agent-prompts' },
+  { plugin: 'enhance', name: 'enhance-claude-memory' },
+  { plugin: 'enhance', name: 'enhance-docs' },
+  { plugin: 'enhance', name: 'enhance-prompts' },
+  { plugin: 'enhance', name: 'enhance-hooks' },
+  { plugin: 'enhance', name: 'enhance-skills' },
+  { plugin: 'enhance', name: 'enhance-cross-file' },
+  { plugin: 'perf', name: 'baseline' },
+  { plugin: 'perf', name: 'benchmark' },
+  { plugin: 'perf', name: 'profile' },
+  { plugin: 'perf', name: 'theory-tester' },
+  { plugin: 'perf', name: 'theory-gatherer' },
+  { plugin: 'perf', name: 'code-paths' },
+  { plugin: 'perf', name: 'investigation-logger' },
+  { plugin: 'perf', name: 'perf-analyzer' },
+  { plugin: 'deslop', name: 'deslop' },
+  { plugin: 'sync-docs', name: 'sync-docs' },
+  { plugin: 'drift-detect', name: 'drift-analysis' },
+  { plugin: 'repo-map', name: 'repo-mapping' },
+  { plugin: 'consult', name: 'consult' },
+  { plugin: 'debate', name: 'debate' },
+  { plugin: 'learn', name: 'learn' },
+  { plugin: 'web-ctl', name: 'web-auth' },
+  { plugin: 'web-ctl', name: 'web-browse' },
+  { plugin: 'ship', name: 'release' },
+  { plugin: 'skillers', name: 'skillers-compact' },
+  { plugin: 'skillers', name: 'recommend' },
+  { plugin: 'git-map', name: 'git-mapping' },
+  { plugin: 'onboard', name: 'onboard' },
+  { plugin: 'can-i-help', name: 'can-i-help' },
+  { plugin: 'audit-project', name: 'audit-project' },
+  { plugin: 'glidemq', name: 'glide-mq' },
+  { plugin: 'glidemq', name: 'glide-mq-migrate-bullmq' },
+  { plugin: 'glidemq', name: 'glide-mq-migrate-bee' }
+];
+
 // Purpose mapping for architecture table
 const PURPOSE_MAP = {
   'next-task': 'Master workflow orchestration',
@@ -73,7 +123,12 @@ const PURPOSE_MAP = {
   'learn': 'Topic research and learning guides',
   'agnix': 'Agent config linting',
   'consult': 'Cross-tool AI consultation',
-  'debate': 'Multi-perspective debate analysis'
+  'debate': 'Multi-perspective debate analysis',
+  'web-ctl': 'Browser automation for AI agents',
+  'skillers': 'Workflow pattern learning',
+  'git-map': 'Git history analysis',
+  'onboard': 'Codebase onboarding',
+  'can-i-help': 'Contributor guidance'
 };
 
 // ---------------------------------------------------------------------------
@@ -122,22 +177,32 @@ function generateCommandsTable(commands) {
   const COMMAND_ORDER = [
     'next-task', 'agnix', 'ship', 'deslop', 'perf',
     'drift-detect', 'audit-project', 'enhance',
-    'repo-map', 'sync-docs', 'learn'
+    'repo-map', 'sync-docs', 'learn', 'consult',
+    'debate', 'web-ctl', 'release', 'skillers',
+    'git-map', 'onboard', 'can-i-help'
   ];
 
   // Command descriptions for the table (short, human-written summaries)
   const COMMAND_SUMMARIES = {
-    'next-task': 'Task \u2192 exploration \u2192 plan \u2192 implementation \u2192 review \u2192 ship',
-    'agnix': '**Lint agent configs** - 155 rules for Skills, Memory, Hooks, MCP across 10+ AI tools',
-    'ship': 'Branch \u2192 PR \u2192 CI \u2192 reviews addressed \u2192 merge \u2192 cleanup',
-    'deslop': '3-phase detection pipeline, certainty-graded findings',
-    'perf': '10-phase performance investigation with baselines and profiling',
-    'drift-detect': 'AST-based plan vs code analysis, finds what\'s documented but not built',
-    'audit-project': 'Multi-agent code review, iterates until issues resolved',
-    'enhance': 'Analyzes prompts, agents, plugins, docs, hooks, skills',
-    'repo-map': 'AST symbol and import mapping via ast-grep',
-    'sync-docs': 'Finds outdated references, stale examples, missing CHANGELOG entries',
-    'learn': 'Research any topic, gather online sources, create learning guide with RAG index'
+    'next-task': 'Task workflow: discovery, implementation, PR, merge',
+    'agnix': 'Lint agent configurations (342 rules)',
+    'ship': 'PR creation, CI monitoring, merge',
+    'deslop': 'Clean AI slop patterns',
+    'perf': 'Performance investigation with baselines and profiling',
+    'drift-detect': 'Compare plan vs implementation',
+    'audit-project': 'Multi-agent iterative code review',
+    'enhance': 'Plugin, agent, and prompt analyzers',
+    'repo-map': 'AST-based repository map',
+    'sync-docs': 'Sync documentation with code changes',
+    'learn': 'Research topics, create learning guides',
+    'consult': 'Cross-tool AI consultation',
+    'debate': 'Structured debate between AI tools',
+    'web-ctl': 'Browser automation for AI agents',
+    'release': 'Versioned release with ecosystem detection',
+    'skillers': 'Workflow pattern learning and automation',
+    'git-map': 'Git history analysis: hotspots, coupling, ownership, bus factor',
+    'onboard': 'Codebase orientation for newcomers',
+    'can-i-help': 'Match contributor skills to project needs'
   };
 
   // Build lookup of discovered commands
@@ -146,12 +211,15 @@ function generateCommandsTable(commands) {
     if (!cmdMap[cmd.name]) cmdMap[cmd.name] = cmd;
   }
 
-  // Emit in curated order, then any new commands not in the list
+  // Emit in curated order. Prefer curated summaries; fall back to discovered frontmatter.
   const emitted = new Set();
   for (const name of COMMAND_ORDER) {
-    if (!cmdMap[name]) continue;
+    let summary = COMMAND_SUMMARIES[name] || '';
+    if (!summary && cmdMap[name]) {
+      summary = cmdMap[name].frontmatter.description || '';
+    }
+    if (!summary && !cmdMap[name]) continue;
     emitted.add(name);
-    const summary = COMMAND_SUMMARIES[name] || cmdMap[name].frontmatter.description || '';
     lines.push(`| [\`/${name}\`](#${name}) | ${summary} |`);
   }
 
@@ -171,14 +239,16 @@ function generateCommandsTable(commands) {
  * Generate the skills table for README.md grouped by category.
  */
 function generateSkillsTable(skills) {
-  const totalSkills = skills.length;
+  // Use static skills as fallback when discovery finds nothing (cross-repo plugins)
+  const effectiveSkills = skills.length > 0 ? skills : STATIC_SKILLS;
+  const totalSkills = effectiveSkills.length;
 
   // Group skills by category
   const groups = {};
-  for (const skill of skills) {
+  for (const skill of effectiveSkills) {
     const category = CATEGORY_MAP[skill.plugin] || 'Other';
     if (!groups[category]) groups[category] = [];
-    groups[category].push(`\`${skill.plugin}:${skill.name}\``);
+    groups[category].push(`\`${skill.name}\``);
   }
 
   // Sort skills within each group
@@ -188,8 +258,9 @@ function generateSkillsTable(skills) {
 
   // Defined category order
   const categoryOrder = [
-    'Performance', 'Enhancement', 'Workflow', 'Cleanup',
-    'Analysis', 'Productivity', 'Learning', 'Linting', 'Other'
+    'Workflow', 'Enhancement', 'Performance', 'Cleanup',
+    'Code Review', 'AI Collaboration', 'Onboarding',
+    'Web', 'Release', 'Analysis', 'Linting', 'Other'
   ];
 
   const lines = [
@@ -318,26 +389,43 @@ function generateAgentCounts(agents, plugins) {
 /**
  * Update counts in site/content.json programmatically.
  */
+// Static counts for cross-repo plugins not discoverable locally
+const STATIC_PLUGIN_COUNT = 19;
+const STATIC_AGENT_COUNT = 38;
+
 function updateSiteContent(plugins, agents, skills) {
   const contentPath = path.join(ROOT_DIR, 'site', 'content.json');
   if (!fs.existsSync(contentPath)) return null;
 
   const content = JSON.parse(fs.readFileSync(contentPath, 'utf8'));
-  const totalAgents = agents.length + ROLE_BASED_AGENT_COUNT;
+
+  // Sync meta.version from package.json
+  const pkgPath = path.join(ROOT_DIR, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    if (content.meta && pkg.version) {
+      content.meta.version = pkg.version;
+    }
+  }
+
+  // Use static counts as fallback (cross-repo plugins not discoverable locally)
+  const effectivePlugins = plugins.length > 0 ? plugins.length : STATIC_PLUGIN_COUNT;
+  const effectiveAgents = agents.length > 0 ? agents.length + ROLE_BASED_AGENT_COUNT : STATIC_AGENT_COUNT;
+  const effectiveSkills = skills.length > 0 ? skills.length : STATIC_SKILLS.length;
 
   // Update stats array
   if (content.stats && Array.isArray(content.stats)) {
     for (const stat of content.stats) {
-      if (stat.label === 'Plugins') stat.value = String(plugins.length);
-      if (stat.label === 'Agents') stat.value = String(totalAgents);
-      if (stat.label === 'Skills') stat.value = String(skills.length);
+      if (stat.label === 'Plugins') stat.value = String(effectivePlugins);
+      if (stat.label === 'Agents') stat.value = String(effectiveAgents);
+      if (stat.label === 'Skills') stat.value = String(effectiveSkills);
     }
   }
 
   // Update agents section
   if (content.agents) {
-    content.agents.total = totalAgents;
-    content.agents.file_based = agents.length;
+    content.agents.total = effectiveAgents;
+    content.agents.file_based = effectiveAgents - ROLE_BASED_AGENT_COUNT;
     content.agents.role_based = ROLE_BASED_AGENT_COUNT;
   }
 
@@ -556,5 +644,8 @@ module.exports = {
   updateSiteContent,
   CATEGORY_MAP,
   PURPOSE_MAP,
-  ROLE_BASED_AGENT_COUNT
+  ROLE_BASED_AGENT_COUNT,
+  STATIC_SKILLS,
+  STATIC_PLUGIN_COUNT,
+  STATIC_AGENT_COUNT
 };

package/scripts/validate-counts.js

@@ -241,7 +241,7 @@ function formatCountMismatch(file, metric, expected, actual) {
  */
 function runValidation() {
   // When plugins/ doesn't exist, counts are not meaningful — return ok
-  if (!fs.existsSync(path.join(REPO_ROOT, 'plugins'))) {
+  if (!fs.existsSync(path.join(REPO_ROOT, 'plugins')) || fs.readdirSync(path.join(REPO_ROOT, 'plugins')).filter(f => fs.statSync(path.join(REPO_ROOT, 'plugins', f)).isDirectory()).length === 0) {
     return {
       status: 'ok',
       message: 'plugins/ not present (extracted to standalone repos)',

package/scripts/validate-cross-platform-docs.js

@@ -251,11 +251,14 @@ function validateFeatureParity() {
   });
 
   // Check that all platforms document all required features
+  // Features documented in general docs (README.md) count for all platforms
+  const generalFeatures = featuresByPlatform.general || new Set();
+
   REQUIRED_FEATURES.forEach(feature => {
     Object.entries(featuresByPlatform).forEach(([platform, features]) => {
-      if (platform === 'general') return; // General docs don't need to list all features
+      if (platform === 'general') return;
 
-      if (!features.has(feature)) {
+      if (!features.has(feature) && !generalFeatures.has(feature)) {
         issues.push({
           platform,
           feature,