claude-flow-novice 1.0.0

package/dist/src/agents/simple-agent.js

@@ -0,0 +1,89 @@
+/**
+ * Simple Agent implementation for novice users
+ */ import { AgentType } from '../types/agent-types.js';
+export class SimpleAgent {
+    config;
+    constructor(config){
+        this.config = config;
+    }
+    /**
+   * Execute the agent's task
+   */ async execute() {
+        console.log(`🤖 ${this.config.type} agent starting task: ${this.config.task}`);
+        // Simulate processing time
+        await this.delay(1000 + Math.random() * 2000);
+        switch(this.config.type){
+            case AgentType.RESEARCHER:
+                return this.executeResearch();
+            case AgentType.CODER:
+                return this.executeCoding();
+            case AgentType.REVIEWER:
+                return this.executeReview();
+            case AgentType.PLANNER:
+                return this.executePlanning();
+            default:
+                throw new Error(`Unknown agent type: ${this.config.type}`);
+        }
+    }
+    async executeResearch() {
+        return `Research completed for: "${this.config.task}"
+
+📊 Research Summary:
+• Key findings identified
+• Relevant sources collected
+• Data analysis performed
+• Recommendations prepared
+
+💡 Next Steps:
+• Review findings with team
+• Implement recommendations
+• Monitor progress`;
+    }
+    async executeCoding() {
+        return `Code implementation for: "${this.config.task}"
+
+💻 Implementation Details:
+• Code structure designed
+• Core functionality implemented
+• Error handling added
+• Documentation included
+
+🧪 Quality Checks:
+• Code reviewed for best practices
+• Performance optimized
+• Security considerations addressed`;
+    }
+    async executeReview() {
+        return `Review completed for: "${this.config.task}"
+
+📋 Review Results:
+• Code quality assessment performed
+• Best practices verification
+• Security audit conducted
+• Performance analysis completed
+
+✅ Recommendations:
+• Minor improvements suggested
+• Overall quality is good
+• Ready for next phase`;
+    }
+    async executePlanning() {
+        return `Planning completed for: "${this.config.task}"
+
+📅 Project Plan:
+• Timeline established
+• Resources identified
+• Milestones defined
+• Risk assessment completed
+
+🎯 Action Items:
+• Begin implementation phase
+• Schedule regular check-ins
+• Monitor progress against milestones`;
+    }
+    delay(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+}
+
+//# sourceMappingURL=simple-agent.js.map

package/dist/src/agents/simple-agent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/agents/simple-agent.ts"],"names":["AgentType","SimpleAgent","config","execute","console","log","type","task","delay","Math","random","RESEARCHER","executeResearch","CODER","executeCoding","REVIEWER","executeReview","PLANNER","executePlanning","Error","ms","Promise","resolve","setTimeout"],"mappings":"AAAA;;CAEC,GAED,SAAsBA,SAAS,QAAQ,0BAA0B;AAEjE,OAAO,MAAMC;;IACX,YAAY,AAAQC,MAAmB,CAAE;aAArBA,SAAAA;IAAsB;IAE1C;;GAEC,GACD,MAAMC,UAA2B;QAC/BC,QAAQC,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,CAACH,MAAM,CAACI,IAAI,CAAC,sBAAsB,EAAE,IAAI,CAACJ,MAAM,CAACK,IAAI,EAAE;QAE7E,2BAA2B;QAC3B,MAAM,IAAI,CAACC,KAAK,CAAC,OAAOC,KAAKC,MAAM,KAAK;QAExC,OAAQ,IAAI,CAACR,MAAM,CAACI,IAAI;YACtB,KAAKN,UAAUW,UAAU;gBACvB,OAAO,IAAI,CAACC,eAAe;YAC7B,KAAKZ,UAAUa,KAAK;gBAClB,OAAO,IAAI,CAACC,aAAa;YAC3B,KAAKd,UAAUe,QAAQ;gBACrB,OAAO,IAAI,CAACC,aAAa;YAC3B,KAAKhB,UAAUiB,OAAO;gBACpB,OAAO,IAAI,CAACC,eAAe;YAC7B;gBACE,MAAM,IAAIC,MAAM,CAAC,oBAAoB,EAAE,IAAI,CAACjB,MAAM,CAACI,IAAI,EAAE;QAC7D;IACF;IAEA,MAAcM,kBAAmC;QAC/C,OAAO,CAAC,yBAAyB,EAAE,IAAI,CAACV,MAAM,CAACK,IAAI,CAAC;;;;;;;;;;;kBAWtC,CAAC;IACjB;IAEA,MAAcO,gBAAiC;QAC7C,OAAO,CAAC,0BAA0B,EAAE,IAAI,CAACZ,MAAM,CAACK,IAAI,CAAC;;;;;;;;;;;mCAWtB,CAAC;IAClC;IAEA,MAAcS,gBAAiC;QAC7C,OAAO,CAAC,uBAAuB,EAAE,IAAI,CAACd,MAAM,CAACK,IAAI,CAAC;;;;;;;;;;;sBAWhC,CAAC;IACrB;IAEA,MAAcW,kBAAmC;QAC/C,OAAO,CAAC,yBAAyB,EAAE,IAAI,CAAChB,MAAM,CAACK,IAAI,CAAC;;;;;;;;;;;qCAWnB,CAAC;IACpC;IAEQC,MAAMY,EAAU,EAAiB;QACvC,OAAO,IAAIC,QAAQ,CAACC,UAAYC,WAAWD,SAASF;IACtD;AACF"}

package/dist/src/agents/task-agent-integration.js

@@ -0,0 +1,240 @@
+/**
+ * Task Agent Integration Layer
+ * Provides validation and fallback for Claude Code's Task tool
+ */ import { validateAgentType } from './agent-validator.js';
+import { getAvailableAgentTypes } from './agent-loader.js';
+/**
+ * Enhanced Task agent spawning with validation and fallbacks
+ */ export class TaskAgentIntegration {
+    static instance;
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new TaskAgentIntegration();
+        }
+        return this.instance;
+    }
+    /**
+   * Validate and prepare agent spawn for Task tool
+   */ async prepareAgentSpawn(request) {
+        const validation = await validateAgentType(request.type);
+        const warnings = [
+            ...validation.warnings
+        ];
+        // Generate the proper Task tool command
+        const spawnCommand = this.generateTaskCommand(request, validation);
+        // Log validation results
+        if (validation.fallbackUsed) {
+            console.warn(`⚠️  Agent type validation for '${request.type}':`);
+            for (const warning of validation.warnings){
+                console.warn(`   ${warning}`);
+            }
+            console.info(`✅ Using validated type: '${validation.resolvedType}'`);
+        }
+        return {
+            originalRequest: request,
+            validationResult: validation,
+            finalType: validation.resolvedType,
+            spawnCommand,
+            warnings,
+            success: true
+        };
+    }
+    /**
+   * Generate the proper Task tool command with validated agent type
+   */ generateTaskCommand(request, validation) {
+        const enhancedPrompt = this.enhancePrompt(request, validation);
+        // Return the command format that Claude Code's Task tool expects
+        return `Task("${request.description}", "${enhancedPrompt}", "${validation.resolvedType}")`;
+    }
+    /**
+   * Enhance the prompt with validation context
+   */ enhancePrompt(request, validation) {
+        let enhancedPrompt = request.prompt;
+        // Add validation context if fallback was used
+        if (validation.fallbackUsed) {
+            enhancedPrompt = `[Agent Type: Originally requested '${validation.originalType}', using '${validation.resolvedType}' as validated type]\n\n${enhancedPrompt}`;
+        }
+        // Add coordination context
+        enhancedPrompt += `\n\n[Coordination Context: Use hooks for coordination - npx claude-flow@alpha hooks pre-task --description "${request.description}"]`;
+        return enhancedPrompt;
+    }
+    /**
+   * Batch validation for multiple agent spawns
+   */ async prepareBatchAgentSpawn(requests) {
+        const results = [];
+        for (const request of requests){
+            try {
+                const result = await this.prepareAgentSpawn(request);
+                results.push(result);
+            } catch (error) {
+                console.error(`Failed to prepare agent spawn for ${request.type}:`, error);
+                // Create error result
+                results.push({
+                    originalRequest: request,
+                    validationResult: {
+                        isValid: false,
+                        resolvedType: 'researcher',
+                        originalType: request.type,
+                        fallbackUsed: true,
+                        warnings: [
+                            `Error validating agent type: ${error}`
+                        ]
+                    },
+                    finalType: 'researcher',
+                    spawnCommand: `Task("${request.description}", "${request.prompt}", "researcher")`,
+                    warnings: [
+                        `Failed to validate ${request.type}, using researcher as fallback`
+                    ],
+                    success: false
+                });
+            }
+        }
+        return results;
+    }
+    /**
+   * Get suggested agent types based on task description
+   */ async suggestAgentTypes(taskDescription) {
+        const availableTypes = await getAvailableAgentTypes();
+        const suggestions = [];
+        // Simple keyword matching for suggestions
+        const keywords = taskDescription.toLowerCase().split(/\s+/);
+        for (const agentType of availableTypes){
+            const agentKeywords = agentType.toLowerCase().split(/[-_]/);
+            // Check for keyword overlap
+            const overlap = keywords.some((keyword)=>agentKeywords.some((agentKeyword)=>agentKeyword.includes(keyword) || keyword.includes(agentKeyword)));
+            if (overlap) {
+                suggestions.push(agentType);
+            }
+        }
+        // If no suggestions, return common types
+        if (suggestions.length === 0) {
+            return [
+                'researcher',
+                'coder',
+                'reviewer',
+                'tester'
+            ];
+        }
+        return suggestions.slice(0, 5); // Limit to 5 suggestions
+    }
+    /**
+   * Validate agent type synchronously (cached results only)
+   */ validateAgentTypeSync(type) {
+        // This would check cache or provide immediate feedback
+        // For now, return basic legacy mapping
+        const legacyMapping = {
+            analyst: 'code-analyzer',
+            'consensus-builder': 'consensus-builder',
+            monitor: 'performance-benchmarker',
+            coordinator: 'hierarchical-coordinator',
+            optimizer: 'perf-analyzer',
+            documenter: 'api-docs',
+            specialist: 'system-architect',
+            architect: 'system-architect'
+        };
+        const resolvedType = legacyMapping[type.toLowerCase()] || type;
+        return {
+            isValid: true,
+            resolvedType
+        };
+    }
+    /**
+   * Get comprehensive agent information for Claude Code
+   */ async getAgentInfo() {
+        const availableTypes = await getAvailableAgentTypes();
+        // Group by category (inferred from naming)
+        const categories = {
+            core: [],
+            development: [],
+            analysis: [],
+            coordination: [],
+            testing: [],
+            specialized: []
+        };
+        for (const type of availableTypes){
+            if (type.includes('coder') || type.includes('dev')) {
+                categories.development.push(type);
+            } else if (type.includes('test')) {
+                categories.testing.push(type);
+            } else if (type.includes('analyz') || type.includes('review')) {
+                categories.analysis.push(type);
+            } else if (type.includes('coordinator') || type.includes('orchestrat')) {
+                categories.coordination.push(type);
+            } else if ([
+                'researcher',
+                'reviewer',
+                'planner'
+            ].includes(type)) {
+                categories.core.push(type);
+            } else {
+                categories.specialized.push(type);
+            }
+        }
+        return {
+            available: availableTypes,
+            categories,
+            legacy: {
+                analyst: 'code-analyzer',
+                'consensus-builder': 'consensus-builder',
+                monitor: 'performance-benchmarker',
+                coordinator: 'hierarchical-coordinator',
+                optimizer: 'perf-analyzer',
+                documenter: 'api-docs',
+                specialist: 'system-architect',
+                architect: 'system-architect'
+            },
+            suggestions: {
+                code: [
+                    'coder',
+                    'reviewer',
+                    'code-analyzer'
+                ],
+                test: [
+                    'tester',
+                    'production-validator'
+                ],
+                design: [
+                    'system-architect',
+                    'base-template-generator'
+                ],
+                analysis: [
+                    'code-analyzer',
+                    'perf-analyzer'
+                ],
+                documentation: [
+                    'api-docs'
+                ],
+                coordination: [
+                    'task-orchestrator',
+                    'hierarchical-coordinator'
+                ]
+            }
+        };
+    }
+}
+// Singleton instance
+export const taskAgentIntegration = TaskAgentIntegration.getInstance();
+// Convenience functions for Claude Code integration
+export const prepareAgentSpawn = (request)=>taskAgentIntegration.prepareAgentSpawn(request);
+export const prepareBatchAgentSpawn = (requests)=>taskAgentIntegration.prepareBatchAgentSpawn(requests);
+export const suggestAgentTypes = (taskDescription)=>taskAgentIntegration.suggestAgentTypes(taskDescription);
+export const validateAgentTypeSync = (type)=>taskAgentIntegration.validateAgentTypeSync(type);
+export const getAgentInfo = ()=>taskAgentIntegration.getAgentInfo();
+/**
+ * Hook for Claude Code to validate agent types before spawning
+ * This can be called by Claude Code's Task tool implementation
+ */ export async function claudeCodeTaskHook(subagentType, description, prompt) {
+    const request = {
+        type: subagentType,
+        description,
+        prompt
+    };
+    const result = await prepareAgentSpawn(request);
+    return {
+        validatedType: result.finalType,
+        enhancedPrompt: result.originalRequest.prompt,
+        warnings: result.warnings
+    };
+}
+
+//# sourceMappingURL=task-agent-integration.js.map

package/dist/src/agents/task-agent-integration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/agents/task-agent-integration.ts"],"names":["validateAgentType","getAvailableAgentTypes","TaskAgentIntegration","instance","getInstance","prepareAgentSpawn","request","validation","type","warnings","spawnCommand","generateTaskCommand","fallbackUsed","console","warn","warning","info","resolvedType","originalRequest","validationResult","finalType","success","enhancedPrompt","enhancePrompt","description","prompt","originalType","prepareBatchAgentSpawn","requests","results","result","push","error","isValid","suggestAgentTypes","taskDescription","availableTypes","suggestions","keywords","toLowerCase","split","agentType","agentKeywords","overlap","some","keyword","agentKeyword","includes","length","slice","validateAgentTypeSync","legacyMapping","analyst","monitor","coordinator","optimizer","documenter","specialist","architect","getAgentInfo","categories","core","development","analysis","coordination","testing","specialized","available","legacy","code","test","design","documentation","taskAgentIntegration","claudeCodeTaskHook","subagentType","validatedType"],"mappings":"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"}