claude-flow-novice 1.3.5 → 1.5.0

package/scripts/build/unified-builder.sh

@@ -153,7 +153,7 @@ build_workaround() {
     echo "$build_output" | grep -v "Import assertions are deprecated" | grep -v "^$" || true
 
     # Check if build was successful by checking for compiled files
-    if [[ -d "dist" ]] && [[ $(find dist -name "*.js" | wc -l) -gt 0 ]]; then
+    if [[ -d ".claude-flow-novice/dist" ]] && [[ $(find .claude-flow-novice/dist -name "*.js" | wc -l) -gt 0 ]]; then
         echo -e "${GREEN}✅ Build successful (workaround mode)${NC}"
         return 0
     else
@@ -400,18 +400,18 @@ main() {
     done
 
     # Final verification - check for compiled JavaScript modules instead of binary
-    if [[ -d "dist" ]] && [[ $(find dist -name "*.js" | wc -l) -gt 0 ]]; then
+    if [[ -d ".claude-flow-novice/dist" ]] && [[ $(find .claude-flow-novice/dist -name "*.js" | wc -l) -gt 0 ]]; then
         echo -e "\n${GREEN}🎉 All build operations completed successfully!${NC}"
-        echo -e "${CYAN}📍 Compiled modules: dist/src/cli/main.js${NC}"
+        echo -e "${CYAN}📍 Compiled modules: .claude-flow-novice/dist/src/cli/main.js${NC}"
         echo -e "${CYAN}📊 Build log: $LOG_FILE${NC}"
 
         # Count compiled files
-        local js_files=$(find dist -name "*.js" | wc -l)
+        local js_files=$(find .claude-flow-novice/dist -name "*.js" | wc -l)
         echo -e "${CYAN}📈 Generated $js_files JavaScript files${NC}"
 
         # Show main entry point
-        if [[ -f "dist/src/cli/main.js" ]]; then
-            echo -e "${GREEN}✅ Main CLI entry point: dist/src/cli/main.js${NC}"
+        if [[ -f ".claude-flow-novice/dist/src/cli/main.js" ]]; then
+            echo -e "${GREEN}✅ Main CLI entry point: .claude-flow-novice/dist/src/cli/main.js${NC}"
         fi
 
         # Coordination hook

package/scripts/build/validate-agents.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+
+/**
+ * Agent Validation Script
+ * Validates Claude Code agent definitions before package distribution
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import yaml from 'yaml';
+import { glob } from 'glob';
+
+const VALID_TOOLS = [
+  'Read', 'Write', 'Edit', 'MultiEdit', 'Bash', 'Glob', 'Grep',
+  'WebSearch', 'WebFetch', 'TodoWrite', 'Task', 'SlashCommand',
+  // MCP coordination tools
+  'mcp__claude-flow-novice__swarm_init', 'mcp__claude-flow-novice__agent_spawn',
+  'mcp__claude-flow-novice__task_orchestrate', 'mcp__claude-flow-novice__memory_usage'
+];
+
+const VALID_MODELS = ['sonnet', 'haiku', 'opus', 'inherit'];
+
+class AgentValidator {
+  constructor() {
+    this.errors = [];
+    this.warnings = [];
+    this.agentCount = 0;
+  }
+
+  log(message, type = 'info') {
+    const timestamp = new Date().toISOString();
+    const prefix = type === 'error' ? '❌' : type === 'warning' ? '⚠️' : 'ℹ️';
+    console.log(`${prefix} [${timestamp}] ${message}`);
+  }
+
+  addError(file, message) {
+    this.errors.push({ file, message });
+    this.log(`Error in ${file}: ${message}`, 'error');
+  }
+
+  addWarning(file, message) {
+    this.warnings.push({ file, message });
+    this.log(`Warning in ${file}: ${message}`, 'warning');
+  }
+
+  validateAgentFile(filePath) {
+    const relativePath = path.relative(process.cwd(), filePath);
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+
+      // Check if file has YAML frontmatter
+      if (!content.startsWith('---')) {
+        this.addError(relativePath, 'Missing YAML frontmatter (should start with ---)');
+        return false;
+      }
+
+      // Extract frontmatter
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (!frontmatterMatch) {
+        this.addError(relativePath, 'Invalid YAML frontmatter format');
+        return false;
+      }
+
+      let frontmatter;
+      try {
+        frontmatter = yaml.parse(frontmatterMatch[1]);
+      } catch (error) {
+        this.addError(relativePath, `Invalid YAML syntax: ${error.message}`);
+        return false;
+      }
+
+      // Validate required fields
+      this.validateRequiredFields(relativePath, frontmatter);
+      this.validateTools(relativePath, frontmatter);
+      this.validateModel(relativePath, frontmatter);
+      this.validateNaming(relativePath, frontmatter, filePath);
+      this.validateSystemPrompt(relativePath, content);
+
+      this.agentCount++;
+      return true;
+
+    } catch (error) {
+      this.addError(relativePath, `Failed to read file: ${error.message}`);
+      return false;
+    }
+  }
+
+  validateRequiredFields(file, frontmatter) {
+    const required = ['name', 'description'];
+
+    for (const field of required) {
+      if (!frontmatter[field]) {
+        this.addError(file, `Missing required field: ${field}`);
+      } else if (typeof frontmatter[field] !== 'string') {
+        this.addError(file, `Field '${field}' must be a string`);
+      }
+    }
+
+    // Validate description is meaningful
+    if (frontmatter.description && frontmatter.description.length < 20) {
+      this.addWarning(file, 'Description should be more descriptive (at least 20 characters)');
+    }
+  }
+
+  validateTools(file, frontmatter) {
+    if (frontmatter.tools) {
+      if (typeof frontmatter.tools === 'string') {
+        // Convert comma-separated string to array
+        const tools = frontmatter.tools.split(',').map(t => t.trim());
+        this.validateToolArray(file, tools);
+      } else if (Array.isArray(frontmatter.tools)) {
+        this.validateToolArray(file, frontmatter.tools);
+      } else {
+        this.addError(file, 'Tools field must be a string or array');
+      }
+    } else {
+      this.addWarning(file, 'No tools specified - agent will inherit all tools');
+    }
+  }
+
+  validateToolArray(file, tools) {
+    for (const tool of tools) {
+      if (!VALID_TOOLS.includes(tool)) {
+        this.addWarning(file, `Unknown tool: ${tool}. Valid tools: ${VALID_TOOLS.join(', ')}`);
+      }
+    }
+  }
+
+  validateModel(file, frontmatter) {
+    if (frontmatter.model && !VALID_MODELS.includes(frontmatter.model)) {
+      this.addWarning(file, `Unknown model: ${frontmatter.model}. Valid models: ${VALID_MODELS.join(', ')}`);
+    }
+  }
+
+  validateNaming(file, frontmatter, filePath) {
+    const fileName = path.basename(filePath, '.md');
+
+    // Check naming convention
+    if (!/^[a-z]+(-[a-z]+)*$/.test(fileName)) {
+      this.addError(file, 'File name should use lowercase-with-hyphens format');
+    }
+
+    // Check name matches file name
+    if (frontmatter.name && frontmatter.name !== fileName) {
+      this.addWarning(file, `Agent name '${frontmatter.name}' doesn't match file name '${fileName}'`);
+    }
+  }
+
+  validateSystemPrompt(file, content) {
+    // Extract system prompt (everything after frontmatter)
+    const promptMatch = content.match(/^---\n[\s\S]*?\n---\n\n?([\s\S]*)$/);
+    if (!promptMatch || !promptMatch[1].trim()) {
+      this.addError(file, 'Missing system prompt after YAML frontmatter');
+      return;
+    }
+
+    const prompt = promptMatch[1].trim();
+
+    // Check prompt length
+    if (prompt.length < 100) {
+      this.addWarning(file, 'System prompt should be more detailed (at least 100 characters)');
+    }
+
+    // Check for key elements
+    const hasExpertise = /expertise|expert|specialist|specializ/i.test(prompt);
+    const hasMethodology = /methodology|approach|process|workflow/i.test(prompt);
+    const hasUsage = /use this|when to|should be used/i.test(prompt);
+
+    if (!hasExpertise) {
+      this.addWarning(file, 'System prompt should define agent expertise');
+    }
+    if (!hasMethodology) {
+      this.addWarning(file, 'System prompt should describe methodology or approach');
+    }
+    if (!hasUsage) {
+      this.addWarning(file, 'System prompt should explain when to use this agent');
+    }
+  }
+
+  async validateAll() {
+    this.log('Starting agent validation...');
+
+    try {
+      // Find all agent files
+      const agentFiles = await glob('.claude/agents/**/*.md');
+
+      if (agentFiles.length === 0) {
+        this.addError('validation', 'No agent files found in .claude/agents/');
+        return false;
+      }
+
+      this.log(`Found ${agentFiles.length} agent files to validate`);
+
+      // Validate each file
+      for (const file of agentFiles) {
+        this.validateAgentFile(file);
+      }
+
+      // Summary
+      this.log(`\n📊 Validation Summary:`);
+      this.log(`   Agents validated: ${this.agentCount}`);
+      this.log(`   Errors: ${this.errors.length}`);
+      this.log(`   Warnings: ${this.warnings.length}`);
+
+      if (this.errors.length > 0) {
+        this.log('\n❌ Validation failed with errors:', 'error');
+        return false;
+      }
+
+      if (this.warnings.length > 0) {
+        this.log('\n⚠️ Validation passed with warnings', 'warning');
+      } else {
+        this.log('\n✅ All agents passed validation!');
+      }
+
+      return true;
+
+    } catch (error) {
+      this.addError('validation', `Validation failed: ${error.message}`);
+      return false;
+    }
+  }
+}
+
+// CLI usage
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const validator = new AgentValidator();
+
+  validator.validateAll().then(success => {
+    process.exit(success ? 0 : 1);
+  }).catch(error => {
+    console.error('❌ Validation crashed:', error);
+    process.exit(1);
+  });
+}
+
+export default AgentValidator;

package/scripts/post-install-claude-md.js

@@ -8,6 +8,7 @@
  */
 
 import { NpxClaudeMdProtection } from '../src/npx/claude-md-protection.js';
+import { execSync } from 'child_process';
 import path from 'path';
 
 async function postInstall() {
@@ -35,6 +36,9 @@ async function postInstall() {
       console.warn('⚠️ CLAUDE.md setup encountered issues:', result.error);
     }
 
+    // Auto-setup MCP server if Claude Code is installed
+    await setupMcpIfAvailable();
+
   } catch (error) {
     console.error('❌ Post-install failed:', error.message);
     // Don't fail the entire install if this fails
@@ -42,6 +46,30 @@ async function postInstall() {
   }
 }
 
+async function setupMcpIfAvailable() {
+  try {
+    // Check if Claude Code CLI is available
+    execSync('which claude', { stdio: 'ignore' });
+
+    console.log('\n🔧 Claude Code detected - setting up MCP server...');
+
+    // Add claude-flow-novice MCP server
+    execSync('claude mcp add claude-flow-novice npx claude-flow-novice mcp start', {
+      stdio: 'inherit'
+    });
+
+    console.log('✅ MCP server added successfully!');
+    console.log('🎯 You can now use claude-flow-novice tools in Claude Code');
+
+  } catch (error) {
+    // Claude Code not installed or MCP add failed - that's fine
+    console.log('\n💡 To use claude-flow-novice with Claude Code:');
+    console.log('   1. Install Claude Code if you haven\'t: npm install -g @anthropic-ai/claude-code');
+    console.log('   2. Add MCP server: claude mcp add claude-flow-novice npx claude-flow-novice mcp start');
+    console.log('   3. Or run: npx claude-flow-novice init');
+  }
+}
+
 // Execute if called directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   postInstall();