agentsys 5.1.0 → 5.2.0

package/plugins/next-task/lib/enhance/cross-file-patterns.js

@@ -1,370 +0,0 @@
-/**
- * Cross-File Semantic Analysis Patterns
- * Detection patterns for multi-file consistency and alignment
- *
- * Cross-platform compatible: Works with Claude Code, OpenCode, and Codex
- *
- * @author Avi Fenesh
- * @license MIT
- */
-
-const fs = require('fs');
-const path = require('path');
-const { getStateDir, getPlatformName } = require('../platform/state-dir');
-
-/**
- * Platform-specific default tools
- * These are used when no tools.json config is found
- */
-const PLATFORM_TOOLS = {
-  claude: [
-    'Task', 'Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash',
-    'WebFetch', 'WebSearch', 'AskUserQuestion', 'NotebookEdit',
-    'LSP', 'Skill', 'EnterPlanMode', 'ExitPlanMode',
-    'TaskCreate', 'TaskUpdate', 'TaskList', 'TaskGet', 'TaskOutput', 'TaskStop'
-  ],
-  opencode: [
-    'Task', 'Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash',
-    'WebFetch', 'WebSearch', 'AskUser', 'Notebook',
-    'LSP', 'Skill', 'Plan'
-  ],
-  codex: [
-    'Task', 'Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash',
-    'WebFetch', 'Ask', 'Shell'
-  ],
-  // Superset for unknown platforms
-  unknown: [
-    'Task', 'Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash',
-    'WebFetch', 'WebSearch', 'AskUserQuestion', 'AskUser', 'Ask',
-    'NotebookEdit', 'Notebook', 'LSP', 'Skill', 'Plan',
-    'EnterPlanMode', 'ExitPlanMode', 'Shell',
-    'TaskCreate', 'TaskUpdate', 'TaskList', 'TaskGet', 'TaskOutput', 'TaskStop'
-  ]
-};
-
-/** Maximum size for tools.json config file (prevents DoS via large files) */
-const MAX_CONFIG_SIZE = 64 * 1024; // 64KB
-
-/**
- * Load tools configuration from state directory or use platform defaults
- * @param {string} [basePath=process.cwd()] - Base path to check
- * @returns {string[]} Array of known tool names
- */
-function loadKnownTools(basePath = process.cwd()) {
-  const stateDir = getStateDir(basePath);
-  const toolsConfigPath = path.join(basePath, stateDir, 'tools.json');
-
-  // Try to load from config file (without race condition)
-  try {
-    const content = fs.readFileSync(toolsConfigPath, 'utf8');
-
-    // Size limit check
-    if (content.length > MAX_CONFIG_SIZE) {
-      if (process.env.DEBUG) {
-        console.error('[cross-file-patterns] tools.json exceeds size limit, using defaults');
-      }
-      throw new Error('Config file too large');
-    }
-
-    const config = JSON.parse(content);
-
-    // Validate config structure
-    if (Array.isArray(config.tools)) {
-      return config.tools;
-    }
-    if (config.knownTools && Array.isArray(config.knownTools)) {
-      return config.knownTools;
-    }
-
-    if (process.env.DEBUG) {
-      console.error('[cross-file-patterns] tools.json missing tools array, using defaults');
-    }
-  } catch (err) {
-    // ENOENT (file not found) is expected, don't log
-    // Other errors should be logged for debugging
-    if (err.code !== 'ENOENT' && process.env.DEBUG) {
-      console.error('[cross-file-patterns] Failed to load tools.json:', err.message);
-    }
-  }
-
-  // Fall back to platform-specific defaults
-  const platform = getPlatformName(basePath);
-  return PLATFORM_TOOLS[platform] || PLATFORM_TOOLS.unknown;
-}
-
-/**
- * Cross-file semantic analysis patterns
- * All patterns use MEDIUM certainty since cross-file analysis requires human review
- */
-const crossFilePatterns = {
-  /**
-   * Tool mentioned in prompt body not in frontmatter tools list
-   */
-  tool_not_in_allowed_list: {
-    id: 'tool_not_in_allowed_list',
-    category: 'tool-consistency',
-    certainty: 'MEDIUM',
-    autoFix: false,
-    description: 'Prompt mentions tools not declared in frontmatter',
-    check: (data) => {
-      const { declaredTools, usedTools, agentName } = data;
-      if (!declaredTools || declaredTools.length === 0) return null;
-      if (!usedTools || usedTools.length === 0) return null;
-
-      // Normalize declared tools (handle Bash(git:*) -> Bash)
-      const normalizedDeclared = declaredTools.map(t => t.split('(')[0].trim());
-
-      const undeclared = usedTools.filter(tool =>
-        !normalizedDeclared.includes(tool) &&
-        !normalizedDeclared.includes('*')
-      );
-
-      if (undeclared.length > 0) {
-        return {
-          issue: `Agent "${agentName}" uses ${undeclared.join(', ')} but not declared in tools frontmatter`,
-          fix: `Add ${undeclared.join(', ')} to tools field or remove usage from prompt`
-        };
-      }
-      return null;
-    }
-  },
-
-  /**
-   * Workflow references an agent that does not exist
-   */
-  missing_workflow_agent: {
-    id: 'missing_workflow_agent',
-    category: 'workflow',
-    certainty: 'MEDIUM',
-    autoFix: false,
-    description: 'Workflow references non-existent agent',
-    check: (data) => {
-      const { referencedAgent, existingAgents, sourceFile } = data;
-      if (!referencedAgent || !existingAgents) return null;
-
-      // Extract plugin:agent format
-      const [plugin, agentName] = referencedAgent.includes(':')
-        ? referencedAgent.split(':')
-        : [null, referencedAgent];
-
-      // Check if agent exists
-      const exists = existingAgents.some(a => {
-        if (plugin) {
-          return a.plugin === plugin && a.name === agentName;
-        }
-        return a.name === agentName;
-      });
-
-      if (!exists) {
-        return {
-          issue: `Referenced agent "${referencedAgent}" does not exist`,
-          fix: `Create agent "${referencedAgent}" or fix the reference in ${sourceFile}`
-        };
-      }
-      return null;
-    }
-  },
-
-  /**
-   * Workflow phases not fully connected
-   */
-  incomplete_phase_transition: {
-    id: 'incomplete_phase_transition',
-    category: 'workflow',
-    certainty: 'MEDIUM',
-    autoFix: false,
-    description: 'Workflow phase transitions are incomplete',
-    check: (data) => {
-      const { phases, transitions, workflowFile } = data;
-      if (!phases || !transitions || phases.length === 0) return null;
-
-      // Check each phase has a transition (except last)
-      const missingTransitions = [];
-      for (let i = 0; i < phases.length - 1; i++) {
-        const currentPhase = phases[i];
-        const hasTransition = transitions.some(t =>
-          t.from === currentPhase || t.to === phases[i + 1]
-        );
-        if (!hasTransition) {
-          missingTransitions.push(`${currentPhase} -> ${phases[i + 1]}`);
-        }
-      }
-
-      if (missingTransitions.length > 0) {
-        return {
-          issue: `Missing phase transitions: ${missingTransitions.join(', ')}`,
-          fix: `Add transition logic for ${missingTransitions[0]} in ${workflowFile}`
-        };
-      }
-      return null;
-    }
-  },
-
-  /**
-   * Duplicate instructions across multiple agents
-   */
-  duplicate_instructions: {
-    id: 'duplicate_instructions',
-    category: 'consistency',
-    certainty: 'MEDIUM',
-    autoFix: false,
-    description: 'Identical critical instructions across agents',
-    check: (data) => {
-      const { instruction, files } = data;
-      if (!instruction || !files || files.length < 2) return null;
-
-      return {
-        issue: `Duplicate instruction found in ${files.length} files: "${instruction.substring(0, 50)}..."`,
-        fix: `Extract shared instruction to a common include or ensure intentional duplication`
-      };
-    }
-  },
-
-  /**
-   * Contradictory rules across agents
-   */
-  contradictory_rules: {
-    id: 'contradictory_rules',
-    category: 'consistency',
-    certainty: 'MEDIUM',
-    autoFix: false,
-    description: 'Conflicting rules across agents (always vs never)',
-    check: (data) => {
-      const { rule1, rule2, file1, file2 } = data;
-      if (!rule1 || !rule2) return null;
-
-      return {
-        issue: `Contradictory rules: "${rule1.substring(0, 40)}..." vs "${rule2.substring(0, 40)}..."`,
-        fix: `Resolve conflict between ${file1} and ${file2}`
-      };
-    }
-  },
-
-  /**
-   * Prompt not referenced by any workflow or skill
-   */
-  orphaned_prompt: {
-    id: 'orphaned_prompt',
-    category: 'consistency',
-    certainty: 'MEDIUM',
-    autoFix: false,
-    description: 'Agent/prompt not referenced anywhere',
-    check: (data) => {
-      const { promptFile, referencedBy } = data;
-      if (!promptFile) return null;
-
-      if (!referencedBy || referencedBy.length === 0) {
-        return {
-          issue: `Orphaned prompt: ${promptFile} is not referenced by any workflow or skill`,
-          fix: `Add reference to ${promptFile} or remove if unused`
-        };
-      }
-      return null;
-    }
-  },
-
-  /**
-   * Skill allowed-tools differs from what prompt uses
-   */
-  skill_tool_mismatch: {
-    id: 'skill_tool_mismatch',
-    category: 'skill-alignment',
-    certainty: 'MEDIUM',
-    autoFix: false,
-    description: 'Skill allowed-tools differs from prompt tool usage',
-    check: (data) => {
-      const { skillName, skillAllowedTools, promptUsedTools } = data;
-      if (!skillAllowedTools || !promptUsedTools) return null;
-
-      // Normalize skill tools
-      const normalizedSkill = skillAllowedTools.map(t => t.split('(')[0].trim());
-
-      const mismatches = promptUsedTools.filter(tool =>
-        !normalizedSkill.includes(tool) &&
-        !normalizedSkill.includes('*')
-      );
-
-      if (mismatches.length > 0) {
-        return {
-          issue: `Skill "${skillName}" prompt uses ${mismatches.join(', ')} not in allowed-tools`,
-          fix: `Add ${mismatches.join(', ')} to skill allowed-tools or update prompt`
-        };
-      }
-      return null;
-    }
-  },
-
-  /**
-   * Skill description does not match actual behavior
-   */
-  skill_description_mismatch: {
-    id: 'skill_description_mismatch',
-    category: 'skill-alignment',
-    certainty: 'MEDIUM',
-    autoFix: false,
-    description: 'Skill description mentions capabilities not found in body',
-    check: (data) => {
-      const { skillName, description, bodyCapabilities, descriptionCapabilities } = data;
-      if (!description || !bodyCapabilities) return null;
-
-      const missingInBody = descriptionCapabilities.filter(cap =>
-        !bodyCapabilities.some(bc => bc.toLowerCase().includes(cap.toLowerCase()))
-      );
-
-      if (missingInBody.length > 0) {
-        return {
-          issue: `Skill "${skillName}" description mentions "${missingInBody[0]}" not found in body`,
-          fix: `Update description to match actual capabilities or add missing functionality`
-        };
-      }
-      return null;
-    }
-  }
-};
-
-/**
- * Get all cross-file patterns
- * @returns {Object} All patterns
- */
-function getAllPatterns() {
-  return crossFilePatterns;
-}
-
-/**
- * Get patterns by category
- * @param {string} category - tool-consistency, workflow, consistency, skill-alignment
- * @returns {Object} Filtered patterns
- */
-function getPatternsByCategory(category) {
-  const result = {};
-  for (const [name, pattern] of Object.entries(crossFilePatterns)) {
-    if (pattern.category === category) {
-      result[name] = pattern;
-    }
-  }
-  return result;
-}
-
-/**
- * Get patterns by certainty
- * @param {string} certainty - HIGH, MEDIUM, LOW
- * @returns {Object} Filtered patterns
- */
-function getPatternsByCertainty(certainty) {
-  const result = {};
-  for (const [name, pattern] of Object.entries(crossFilePatterns)) {
-    if (pattern.certainty === certainty) {
-      result[name] = pattern;
-    }
-  }
-  return result;
-}
-
-module.exports = {
-  PLATFORM_TOOLS,
-  loadKnownTools,
-  crossFilePatterns,
-  getAllPatterns,
-  getPatternsByCategory,
-  getPatternsByCertainty
-};

package/plugins/next-task/lib/enhance/docs-analyzer.js

@@ -1,325 +0,0 @@
-/**
- * Documentation Analyzer
- * @author Avi Fenesh
- * @license MIT
- */
-
-const fs = require('fs');
-const path = require('path');
-const { getPatternsForMode, estimateTokens } = require('./docs-patterns');
-
-function analyzeDoc(docPath, options = {}) {
-  const { mode = 'both', verbose = false, existingFiles = [] } = options;
-
-  const results = {
-    docName: path.basename(docPath, '.md'),
-    docPath,
-    mode,
-    tokenCount: 0,
-    linkIssues: [],
-    structureIssues: [],
-    codeIssues: [],
-    efficiencyIssues: [],
-    ragIssues: [],
-    balanceIssues: []
-  };
-
-  // Read file
-  if (!fs.existsSync(docPath)) {
-    results.structureIssues.push({
-      issue: 'File not found',
-      file: docPath,
-      certainty: 'HIGH',
-      patternId: 'file_not_found'
-    });
-    return results;
-  }
-
-  let content;
-  try {
-    content = fs.readFileSync(docPath, 'utf8');
-  } catch (err) {
-    results.structureIssues.push({
-      issue: `Failed to read file: ${err.message}`,
-      file: docPath,
-      certainty: 'HIGH',
-      patternId: 'read_error'
-    });
-    return results;
-  }
-
-  // Calculate token count
-  results.tokenCount = estimateTokens(content);
-
-  // Get patterns applicable to this mode
-  const patterns = getPatternsForMode(mode);
-
-  // Context for pattern checks
-  const context = { existingFiles };
-
-  // Run each pattern check
-  for (const [patternName, pattern] of Object.entries(patterns)) {
-    // Skip LOW certainty unless verbose
-    if (pattern.certainty === 'LOW' && !verbose) {
-      continue;
-    }
-
-    // Run the check
-    const result = pattern.check(content, context);
-
-    if (result) {
-      const issue = {
-        ...result,
-        file: docPath,
-        certainty: pattern.certainty,
-        patternId: pattern.id,
-        autoFix: pattern.autoFix
-      };
-
-      // Route to appropriate issue category
-      switch (pattern.category) {
-        case 'link':
-          results.linkIssues.push(issue);
-          break;
-        case 'structure':
-          results.structureIssues.push(issue);
-          break;
-        case 'code':
-          results.codeIssues.push(issue);
-          break;
-        case 'efficiency':
-          results.efficiencyIssues.push(issue);
-          break;
-        case 'rag':
-          results.ragIssues.push(issue);
-          break;
-        case 'balance':
-          results.balanceIssues.push(issue);
-          break;
-        default:
-          results.structureIssues.push(issue);
-      }
-    }
-  }
-
-  return results;
-}
-
-function analyzeAllDocs(docsDir, options = {}) {
-  const { recursive = true, ...analyzeOptions } = options;
-  const results = [];
-
-  if (!fs.existsSync(docsDir)) {
-    return results;
-  }
-
-  // Collect all markdown files
-  const mdFiles = [];
-
-  function findMdFiles(dir) {
-    let entries;
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch (err) {
-      return;
-    }
-
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-
-      if (entry.isDirectory() && recursive) {
-        // Skip common non-doc directories
-        if (!['node_modules', '.git', 'dist', 'build'].includes(entry.name)) {
-          findMdFiles(fullPath);
-        }
-      } else if (entry.isFile() && entry.name.endsWith('.md')) {
-        // Skip README files in nested directories for agent-docs mode
-        if (options.mode === 'ai' && entry.name === 'README.md') {
-          continue;
-        }
-        mdFiles.push(fullPath);
-      }
-    }
-  }
-
-  findMdFiles(docsDir);
-
-  // Get relative paths for link validation
-  const existingFiles = mdFiles.map(f => path.relative(docsDir, f).replace(/\\/g, '/'));
-
-  // Analyze each file
-  for (const mdFile of mdFiles) {
-    const result = analyzeDoc(mdFile, { ...analyzeOptions, existingFiles });
-    results.push(result);
-  }
-
-  return results;
-}
-
-function analyze(options = {}) {
-  const {
-    doc,
-    docsDir = 'docs',
-    mode = 'both',
-    verbose = false
-  } = options;
-
-  if (doc) {
-    // Check if doc is a directory or file
-    try {
-      const stats = fs.statSync(doc);
-      if (stats.isDirectory()) {
-        // Analyze all docs in directory
-        return analyzeAllDocs(doc, { mode, verbose });
-      } else {
-        // Analyze single doc
-        return analyzeDoc(doc, { mode, verbose });
-      }
-    } catch (err) {
-      // If file doesn't exist, let analyzeDoc handle the error
-      return analyzeDoc(doc, { mode, verbose });
-    }
-  } else {
-    // Analyze all docs in directory
-    return analyzeAllDocs(docsDir, { mode, verbose });
-  }
-}
-
-function applyFixes(results, options = {}) {
-  // Collect all issues
-  let allIssues = [];
-
-  if (Array.isArray(results)) {
-    for (const r of results) {
-      allIssues.push(...(r.linkIssues || []));
-      allIssues.push(...(r.structureIssues || []));
-      allIssues.push(...(r.codeIssues || []));
-      allIssues.push(...(r.efficiencyIssues || []));
-      allIssues.push(...(r.ragIssues || []));
-      allIssues.push(...(r.balanceIssues || []));
-    }
-  } else {
-    allIssues.push(...(results.linkIssues || []));
-    allIssues.push(...(results.structureIssues || []));
-    allIssues.push(...(results.codeIssues || []));
-    allIssues.push(...(results.efficiencyIssues || []));
-    allIssues.push(...(results.ragIssues || []));
-    allIssues.push(...(results.balanceIssues || []));
-  }
-
-  // Filter to auto-fixable docs issues
-  const docsFixablePatternIds = [
-    'inconsistent_heading_levels',
-    'verbose_explanations'
-  ];
-
-  const fixableIssues = allIssues.filter(i =>
-    i.certainty === 'HIGH' &&
-    i.autoFix &&
-    docsFixablePatternIds.includes(i.patternId)
-  );
-
-  // Apply fixes using the fixer module's pattern
-  return applyDocsFixes(fixableIssues, options);
-}
-
-function applyDocsFixes(issues, options = {}) {
-  const { dryRun = false, backup = true } = options;
-  const fixer = require('./fixer');
-
-  const results = {
-    applied: [],
-    skipped: [],
-    errors: []
-  };
-
-  // Group by file
-  const byFile = new Map();
-  for (const issue of issues) {
-    const fp = issue.file;
-    if (!byFile.has(fp)) {
-      byFile.set(fp, []);
-    }
-    byFile.get(fp).push(issue);
-  }
-
-  // Process each file
-  for (const [filePath, fileIssues] of byFile) {
-    try {
-      if (!fs.existsSync(filePath)) {
-        results.errors.push({ filePath, error: 'File not found' });
-        continue;
-      }
-
-      let content = fs.readFileSync(filePath, 'utf8');
-      const appliedToFile = [];
-
-      for (const issue of fileIssues) {
-        try {
-          if (issue.patternId === 'inconsistent_heading_levels') {
-            content = fixer.fixInconsistentHeadings(content);
-            appliedToFile.push({
-              issue: issue.issue,
-              fix: 'Fixed heading levels',
-              filePath
-            });
-          } else if (issue.patternId === 'verbose_explanations') {
-            content = fixer.fixVerboseExplanations(content);
-            appliedToFile.push({
-              issue: issue.issue,
-              fix: 'Simplified verbose phrases',
-              filePath
-            });
-          }
-        } catch (err) {
-          results.errors.push({
-            issue: issue.issue,
-            filePath,
-            error: err.message
-          });
-        }
-      }
-
-      // Write changes
-      if (!dryRun && appliedToFile.length > 0) {
-        if (backup) {
-          fs.writeFileSync(`${filePath}.backup`, fs.readFileSync(filePath, 'utf8'), 'utf8');
-        }
-        fs.writeFileSync(filePath, content, 'utf8');
-      }
-
-      results.applied.push(...appliedToFile);
-
-    } catch (err) {
-      results.errors.push({
-        filePath,
-        error: err.message
-      });
-    }
-  }
-
-  return results;
-}
-
-function generateReport(results, options = {}) {
-  const reporter = require('./reporter');
-
-  if (Array.isArray(results)) {
-    return reporter.generateDocsSummaryReport(results, options);
-  } else {
-    return reporter.generateDocsReport(results, options);
-  }
-}
-
-const fixer = require('./fixer');
-
-module.exports = {
-  analyzeDoc,
-  analyzeAllDocs,
-  analyze,
-  applyFixes,
-  applyDocsFixes,
-  fixInconsistentHeadings: fixer.fixInconsistentHeadings,
-  fixVerboseExplanations: fixer.fixVerboseExplanations,
-  generateReport
-};