agentic-flow 1.0.7 → 1.0.8

package/dist/cli/agent-manager.js

@@ -0,0 +1,451 @@
+#!/usr/bin/env node
+/**
+ * Agent Management CLI - Create, list, and manage custom agents
+ * Supports both npm package agents and local .claude/agents
+ * Includes conflict detection and deduplication
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'fs';
+import { join, dirname, relative, extname } from 'path';
+import { fileURLToPath } from 'url';
+import { createInterface } from 'readline';
+// Get package root and default paths
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageRoot = join(__dirname, '../..');
+const packageAgentsDir = join(packageRoot, '.claude/agents');
+const localAgentsDir = join(process.cwd(), '.claude/agents');
+export class AgentManager {
+    /**
+     * Find all agent files from both package and local directories
+     * Deduplicates by preferring local over package
+     */
+    findAllAgents() {
+        const agents = new Map();
+        // Load package agents first
+        if (existsSync(packageAgentsDir)) {
+            this.scanAgentsDirectory(packageAgentsDir, 'package', agents);
+        }
+        // Load local agents (overrides package agents with same relative path)
+        if (existsSync(localAgentsDir)) {
+            this.scanAgentsDirectory(localAgentsDir, 'local', agents);
+        }
+        return agents;
+    }
+    /**
+     * Recursively scan directory for agent markdown files
+     */
+    scanAgentsDirectory(dir, source, agents) {
+        const baseDir = source === 'package' ? packageAgentsDir : localAgentsDir;
+        try {
+            const entries = readdirSync(dir);
+            for (const entry of entries) {
+                const fullPath = join(dir, entry);
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    this.scanAgentsDirectory(fullPath, source, agents);
+                }
+                else if (extname(entry) === '.md' && entry !== 'README.md') {
+                    const relativePath = relative(baseDir, fullPath);
+                    const agentInfo = this.parseAgentFile(fullPath, source, relativePath);
+                    if (agentInfo) {
+                        // Use relative path as key for deduplication
+                        // Local agents override package agents
+                        const existingAgent = agents.get(relativePath);
+                        if (!existingAgent || source === 'local') {
+                            agents.set(relativePath, agentInfo);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error scanning directory ${dir}: ${error.message}`);
+        }
+    }
+    /**
+     * Parse agent markdown file and extract metadata
+     */
+    parseAgentFile(filePath, source, relativePath) {
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            // Try frontmatter format first
+            const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+            if (frontmatterMatch) {
+                const [, frontmatter] = frontmatterMatch;
+                const meta = {};
+                frontmatter.split('\n').forEach(line => {
+                    const match = line.match(/^(\w+):\s*(.+)$/);
+                    if (match) {
+                        const [, key, value] = match;
+                        meta[key] = value.replace(/^["']|["']$/g, '');
+                    }
+                });
+                if (meta.name && meta.description) {
+                    return {
+                        name: meta.name,
+                        description: meta.description,
+                        category: this.getCategoryFromPath(relativePath),
+                        filePath,
+                        source,
+                        relativePath
+                    };
+                }
+            }
+            // Fallback: extract from markdown headers
+            const nameMatch = content.match(/^#\s+(.+)$/m);
+            const descMatch = content.match(/^##\s+Description\s*\n\s*(.+)$/m);
+            if (nameMatch) {
+                return {
+                    name: nameMatch[1].trim(),
+                    description: descMatch ? descMatch[1].trim() : 'No description available',
+                    category: this.getCategoryFromPath(relativePath),
+                    filePath,
+                    source,
+                    relativePath
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Get category from file path
+     */
+    getCategoryFromPath(relativePath) {
+        const parts = relativePath.split('/');
+        return parts.length > 1 ? parts[0] : 'custom';
+    }
+    /**
+     * List all agents with deduplication
+     */
+    list(format = 'summary') {
+        const agents = this.findAllAgents();
+        if (format === 'json') {
+            const agentList = Array.from(agents.values()).map(a => ({
+                name: a.name,
+                description: a.description,
+                category: a.category,
+                source: a.source,
+                path: a.relativePath
+            }));
+            console.log(JSON.stringify(agentList, null, 2));
+            return;
+        }
+        // Group by category
+        const byCategory = new Map();
+        for (const agent of agents.values()) {
+            const category = agent.category;
+            if (!byCategory.has(category)) {
+                byCategory.set(category, []);
+            }
+            byCategory.get(category).push(agent);
+        }
+        // Sort categories
+        const sortedCategories = Array.from(byCategory.keys()).sort();
+        console.log('\n📦 Available Agents:');
+        console.log('═'.repeat(80));
+        for (const category of sortedCategories) {
+            const categoryAgents = byCategory.get(category).sort((a, b) => a.name.localeCompare(b.name));
+            console.log(`\n${category.toUpperCase()}:`);
+            for (const agent of categoryAgents) {
+                const sourceIcon = agent.source === 'local' ? '📝' : '📦';
+                if (format === 'detailed') {
+                    console.log(`  ${sourceIcon} ${agent.name}`);
+                    console.log(`     ${agent.description}`);
+                    console.log(`     Source: ${agent.source} (${agent.relativePath})`);
+                }
+                else {
+                    console.log(`  ${sourceIcon} ${agent.name.padEnd(30)} ${agent.description.substring(0, 45)}...`);
+                }
+            }
+        }
+        console.log(`\n📊 Total: ${agents.size} agents`);
+        console.log(`   📝 Local: ${Array.from(agents.values()).filter(a => a.source === 'local').length}`);
+        console.log(`   📦 Package: ${Array.from(agents.values()).filter(a => a.source === 'package').length}`);
+        console.log('');
+    }
+    /**
+     * Create a new agent
+     */
+    async create(options) {
+        let { name, description, category, systemPrompt, tools } = options;
+        // Interactive mode
+        if (options.interactive) {
+            const rl = createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            const question = (prompt) => {
+                return new Promise(resolve => rl.question(prompt, resolve));
+            };
+            console.log('\n🤖 Create New Agent');
+            console.log('═'.repeat(80));
+            name = await question('Agent name (e.g., my-custom-agent): ');
+            description = await question('Description: ');
+            category = await question('Category (default: custom): ') || 'custom';
+            systemPrompt = await question('System prompt: ');
+            const toolsInput = await question('Tools (comma-separated, optional): ');
+            tools = toolsInput ? toolsInput.split(',').map(t => t.trim()) : [];
+            rl.close();
+        }
+        // Validate required fields
+        if (!name || !description || !systemPrompt) {
+            throw new Error('Name, description, and system prompt are required');
+        }
+        // Normalize name to kebab-case
+        const kebabName = name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+        // Check for conflicts
+        const agents = this.findAllAgents();
+        const conflictingAgent = Array.from(agents.values()).find(a => a.name.toLowerCase() === kebabName.toLowerCase());
+        if (conflictingAgent) {
+            console.log(`\n⚠️  Warning: Agent "${conflictingAgent.name}" already exists`);
+            console.log(`   Source: ${conflictingAgent.source}`);
+            console.log(`   Path: ${conflictingAgent.relativePath}`);
+            const rl = createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            const answer = await new Promise(resolve => {
+                rl.question('\nCreate in local .claude/agents anyway? (y/N): ', resolve);
+            });
+            rl.close();
+            if (answer.toLowerCase() !== 'y') {
+                console.log('Cancelled.');
+                return;
+            }
+        }
+        // Create directory structure
+        const targetCategory = category || 'custom';
+        const targetDir = join(localAgentsDir, targetCategory);
+        if (!existsSync(targetDir)) {
+            mkdirSync(targetDir, { recursive: true });
+        }
+        // Generate markdown content
+        const markdown = this.generateAgentMarkdown({
+            name: kebabName,
+            description: description,
+            category: targetCategory,
+            tools
+        }, systemPrompt);
+        const filePath = join(targetDir, `${kebabName}.md`);
+        if (existsSync(filePath)) {
+            throw new Error(`Agent file already exists at ${filePath}`);
+        }
+        writeFileSync(filePath, markdown, 'utf8');
+        console.log(`\n✅ Agent created successfully!`);
+        console.log(`   Name: ${kebabName}`);
+        console.log(`   Category: ${targetCategory}`);
+        console.log(`   Path: ${filePath}`);
+        console.log(`\n📝 Usage:`);
+        console.log(`   npx agentic-flow --agent ${kebabName} --task "Your task"`);
+        console.log('');
+    }
+    /**
+     * Generate agent markdown with frontmatter
+     */
+    generateAgentMarkdown(metadata, systemPrompt) {
+        const toolsLine = metadata.tools && metadata.tools.length > 0
+            ? `tools: ${metadata.tools.join(', ')}`
+            : '';
+        return `---
+name: ${metadata.name}
+description: ${metadata.description}
+${metadata.color ? `color: ${metadata.color}` : ''}
+${toolsLine}
+---
+
+${systemPrompt}
+
+## Usage
+
+\`\`\`bash
+npx agentic-flow --agent ${metadata.name} --task "Your task"
+\`\`\`
+
+## Examples
+
+### Example 1
+\`\`\`bash
+npx agentic-flow --agent ${metadata.name} --task "Example task description"
+\`\`\`
+
+---
+*Created: ${new Date().toISOString()}*
+*Source: local*
+`;
+    }
+    /**
+     * Get information about a specific agent
+     */
+    info(name) {
+        const agents = this.findAllAgents();
+        const agent = Array.from(agents.values()).find(a => a.name.toLowerCase() === name.toLowerCase());
+        if (!agent) {
+            console.log(`\n❌ Agent "${name}" not found`);
+            console.log('\nUse "agentic-flow agent list" to see all available agents\n');
+            return;
+        }
+        console.log('\n📋 Agent Information');
+        console.log('═'.repeat(80));
+        console.log(`Name:        ${agent.name}`);
+        console.log(`Description: ${agent.description}`);
+        console.log(`Category:    ${agent.category}`);
+        console.log(`Source:      ${agent.source === 'local' ? '📝 Local' : '📦 Package'}`);
+        console.log(`Path:        ${agent.relativePath}`);
+        console.log(`Full Path:   ${agent.filePath}`);
+        console.log('');
+        // Show content preview
+        try {
+            const content = readFileSync(agent.filePath, 'utf-8');
+            console.log('Preview:');
+            console.log('─'.repeat(80));
+            const lines = content.split('\n').slice(0, 20);
+            console.log(lines.join('\n'));
+            if (content.split('\n').length > 20) {
+                console.log('...');
+            }
+            console.log('');
+        }
+        catch (error) {
+            console.log('Could not read agent file\n');
+        }
+    }
+    /**
+     * Check for conflicts between package and local agents
+     */
+    checkConflicts() {
+        console.log('\n🔍 Checking for agent conflicts...');
+        console.log('═'.repeat(80));
+        const packageAgents = new Map();
+        const localAgents = new Map();
+        if (existsSync(packageAgentsDir)) {
+            this.scanAgentsDirectory(packageAgentsDir, 'package', packageAgents);
+        }
+        if (existsSync(localAgentsDir)) {
+            this.scanAgentsDirectory(localAgentsDir, 'local', localAgents);
+        }
+        // Find conflicts (same relative path in both)
+        const conflicts = [];
+        for (const [relativePath, localAgent] of localAgents) {
+            const packageAgent = packageAgents.get(relativePath);
+            if (packageAgent) {
+                conflicts.push({ path: relativePath, package: packageAgent, local: localAgent });
+            }
+        }
+        if (conflicts.length === 0) {
+            console.log('\n✅ No conflicts found!\n');
+            return;
+        }
+        console.log(`\n⚠️  Found ${conflicts.length} conflict(s):\n`);
+        for (const conflict of conflicts) {
+            console.log(`📁 ${conflict.path}`);
+            console.log(`   📦 Package: ${conflict.package.name}`);
+            console.log(`      ${conflict.package.description}`);
+            console.log(`   📝 Local:   ${conflict.local.name}`);
+            console.log(`      ${conflict.local.description}`);
+            console.log(`   ℹ️  Local version will be used\n`);
+        }
+    }
+}
+/**
+ * CLI command handler
+ */
+export async function handleAgentCommand(args) {
+    const command = args[0];
+    const manager = new AgentManager();
+    switch (command) {
+        case undefined:
+        case 'help':
+            console.log(`
+🤖 Agent Management CLI
+
+USAGE:
+  npx agentic-flow agent <command> [options]
+
+COMMANDS:
+  list [format]           List all available agents
+                          format: summary (default), detailed, json
+
+  create                  Create a new agent interactively
+  create --name NAME      Create agent with CLI arguments
+         --description DESC
+         --category CAT
+         --prompt PROMPT
+         [--tools TOOLS]
+
+  info <name>            Show detailed information about an agent
+
+  conflicts              Check for conflicts between package and local agents
+
+  help                   Show this help message
+
+EXAMPLES:
+  # List all agents
+  npx agentic-flow agent list
+
+  # List with details
+  npx agentic-flow agent list detailed
+
+  # Create agent interactively
+  npx agentic-flow agent create
+
+  # Create agent with CLI
+  npx agentic-flow agent create --name my-agent --description "My custom agent" --prompt "You are a helpful assistant"
+
+  # Get agent info
+  npx agentic-flow agent info coder
+
+  # Check conflicts
+  npx agentic-flow agent conflicts
+
+AGENT LOCATIONS:
+  📦 Package: ${packageAgentsDir}
+  📝 Local:   ${localAgentsDir}
+
+  Note: Local agents override package agents with the same path.
+`);
+            break;
+        case 'list':
+            const format = args[1] || 'summary';
+            manager.list(format);
+            break;
+        case 'create':
+            const nameIdx = args.indexOf('--name');
+            const descIdx = args.indexOf('--description');
+            const catIdx = args.indexOf('--category');
+            const promptIdx = args.indexOf('--prompt');
+            const toolsIdx = args.indexOf('--tools');
+            if (nameIdx === -1 || descIdx === -1 || promptIdx === -1) {
+                // Interactive mode
+                await manager.create({ interactive: true });
+            }
+            else {
+                // CLI mode
+                await manager.create({
+                    name: args[nameIdx + 1],
+                    description: args[descIdx + 1],
+                    category: catIdx !== -1 ? args[catIdx + 1] : 'custom',
+                    systemPrompt: args[promptIdx + 1],
+                    tools: toolsIdx !== -1 ? args[toolsIdx + 1].split(',').map(t => t.trim()) : []
+                });
+            }
+            break;
+        case 'info':
+            if (!args[1]) {
+                console.log('\n❌ Please specify an agent name\n');
+                console.log('Usage: npx agentic-flow agent info <name>\n');
+                process.exit(1);
+            }
+            manager.info(args[1]);
+            break;
+        case 'conflicts':
+            manager.checkConflicts();
+            break;
+        default:
+            console.log(`\n❌ Unknown command: ${command}\n`);
+            console.log('Use "npx agentic-flow agent help" for usage information\n');
+            process.exit(1);
+    }
+}

package/dist/cli-proxy.js

@@ -10,6 +10,7 @@ import { parseArgs } from "./utils/cli.js";
 import { getAgent, listAgents } from "./utils/agentLoader.js";
 import { directApiAgent } from "./agents/directApiAgent.js";
 import { handleConfigCommand } from "./cli/config-wizard.js";
+import { handleAgentCommand } from "./cli/agent-manager.js";
 import { readFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
@@ -36,6 +37,12 @@ class AgenticFlowCLI {
             await handleConfigCommand(configArgs);
             process.exit(0);
         }
+        if (options.mode === 'agent-manager') {
+            // Handle agent management commands
+            const agentArgs = process.argv.slice(3); // Skip 'node', 'cli-proxy.js', 'agent'
+            await handleAgentCommand(agentArgs);
+            process.exit(0);
+        }
         if (options.mode === 'mcp') {
             // Run standalone MCP server directly
             const { spawn } = await import('child_process');
@@ -235,6 +242,7 @@ USAGE:
 COMMANDS:
   config [subcommand]     Manage environment configuration (interactive wizard)
   mcp <command> [server]  Manage MCP servers (start, stop, status, list)
+  agent <command>         Agent management (list, create, info, conflicts)
   --list, -l              List all available agents
   --agent, -a <name>      Run specific agent mode
 
@@ -254,12 +262,37 @@ MCP COMMANDS:
 
   Available servers: claude-flow, flow-nexus, agentic-payments, all (default)
 
+AGENT COMMANDS:
+  npx agentic-flow agent list [format]   List all agents (summary/detailed/json)
+  npx agentic-flow agent create          Create new custom agent (interactive)
+  npx agentic-flow agent info <name>     Show detailed agent information
+  npx agentic-flow agent conflicts       Check for package/local conflicts
+
 OPTIONS:
-  --task, -t <task>       Task description for agent mode
-  --model, -m <model>     Model to use (triggers OpenRouter if contains "/")
-  --provider, -p <name>   Provider to use (anthropic, openrouter, onnx)
-  --stream, -s            Enable real-time streaming output
-  --help, -h              Show this help message
+  --task, -t <task>           Task description for agent mode
+  --model, -m <model>         Model to use (triggers OpenRouter if contains "/")
+  --provider, -p <name>       Provider to use (anthropic, openrouter, onnx)
+  --stream, -s                Enable real-time streaming output
+  --help, -h                  Show this help message
+
+  API CONFIGURATION:
+  --anthropic-key <key>       Override ANTHROPIC_API_KEY environment variable
+  --openrouter-key <key>      Override OPENROUTER_API_KEY environment variable
+
+  AGENT BEHAVIOR:
+  --temperature <0.0-1.0>     Sampling temperature (creativity control)
+  --max-tokens <number>       Maximum tokens in response
+
+  DIRECTORY:
+  --agents-dir <path>         Custom agents directory (default: .claude/agents)
+
+  OUTPUT:
+  --output <text|json|md>     Output format (text/json/markdown)
+  --verbose                   Enable verbose logging for debugging
+
+  EXECUTION:
+  --timeout <ms>              Execution timeout in milliseconds
+  --retry                     Auto-retry on transient errors
 
 EXAMPLES:
   # MCP Server Management
@@ -288,11 +321,11 @@ OPENROUTER MODELS:
   - google/gemini-2.5-flash-preview (fastest)
   - See https://openrouter.ai/models for full list
 
-MCP TOOLS (203+ available):
-  • claude-flow-sdk: 6 in-process tools (memory, swarm coordination)
+MCP TOOLS (209+ available):
+  • agentic-flow: 6 tools (agent execution, creation, management)
   • claude-flow: 101 tools (neural networks, GitHub, workflows, DAA)
   • flow-nexus: 96 cloud tools (sandboxes, distributed swarms, templates)
-  • agentic-payments: Payment authorization and multi-agent consensus
+  • agentic-payments: 6 tools (payment authorization, multi-agent consensus)
 
 For more information: https://github.com/ruvnet/agentic-flow
     `);

package/dist/mcp/standalone-stdio.js

@@ -19,7 +19,7 @@ console.error('🚀 Starting Agentic-Flow MCP Server (stdio)...');
 console.error('📦 Local agentic-flow tools available');
 const server = new FastMCP({
     name: 'agentic-flow',
-    version: '1.0.7'
+    version: '1.0.8'
 });
 // Tool: Run agentic-flow agent
 server.addTool({
@@ -124,7 +124,138 @@ server.addTool({
         }
     }
 });
-console.error('✅ Registered 2 tools: agentic_flow_agent, agentic_flow_list_agents');
+// Tool: Create custom agent
+server.addTool({
+    name: 'agentic_flow_create_agent',
+    description: 'Create a new custom agent in .claude/agents directory. Supports conflict detection and will warn if agent already exists in package or local directories.',
+    parameters: z.object({
+        name: z.string().describe('Agent name (will be converted to kebab-case, e.g., my-custom-agent)'),
+        description: z.string().describe('Agent description (what this agent does)'),
+        systemPrompt: z.string().describe('System prompt that defines the agent behavior and personality'),
+        category: z.string().optional().default('custom').describe('Category/folder to organize the agent (default: custom)'),
+        tools: z.array(z.string()).optional().describe('Optional list of tools this agent can use (e.g., ["web-search", "code-execution"])')
+    }),
+    execute: async ({ name, description, systemPrompt, category, tools }) => {
+        try {
+            let cmd = `npx --yes agentic-flow agent create --name "${name}" --description "${description}" --prompt "${systemPrompt}"`;
+            if (category && category !== 'custom')
+                cmd += ` --category "${category}"`;
+            if (tools && tools.length > 0)
+                cmd += ` --tools "${tools.join(',')}"`;
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024,
+                timeout: 60000,
+                input: 'y\n' // Auto-confirm if conflict exists
+            });
+            return JSON.stringify({
+                success: true,
+                name,
+                category: category || 'custom',
+                message: 'Agent created successfully',
+                output: result.trim()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to create agent: ${error.message}`);
+        }
+    }
+});
+// Tool: List agents with source information
+server.addTool({
+    name: 'agentic_flow_list_all_agents',
+    description: 'List all available agents including both package agents and custom local agents. Shows source (package or local) and handles deduplication.',
+    parameters: z.object({
+        format: z.enum(['summary', 'detailed', 'json']).optional().default('summary').describe('Output format: summary (brief list), detailed (full info), json (structured data)'),
+        filterSource: z.enum(['all', 'package', 'local']).optional().default('all').describe('Filter by source: all, package (npm distribution), or local (custom .claude/agents)')
+    }),
+    execute: async ({ format, filterSource }) => {
+        try {
+            const cmd = `npx --yes agentic-flow agent list ${format || 'summary'}`;
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024,
+                timeout: 30000
+            });
+            if (format === 'json') {
+                const agents = JSON.parse(result);
+                const filtered = filterSource && filterSource !== 'all'
+                    ? agents.filter((a) => a.source === filterSource)
+                    : agents;
+                return JSON.stringify({
+                    success: true,
+                    count: filtered.length,
+                    filterSource: filterSource || 'all',
+                    agents: filtered
+                }, null, 2);
+            }
+            return JSON.stringify({
+                success: true,
+                filterSource: filterSource || 'all',
+                output: result.trim()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to list agents: ${error.message}`);
+        }
+    }
+});
+// Tool: Get agent information
+server.addTool({
+    name: 'agentic_flow_agent_info',
+    description: 'Get detailed information about a specific agent including its source, description, category, and system prompt preview.',
+    parameters: z.object({
+        name: z.string().describe('Agent name to get information about')
+    }),
+    execute: async ({ name }) => {
+        try {
+            const cmd = `npx --yes agentic-flow agent info "${name}"`;
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024,
+                timeout: 30000
+            });
+            return JSON.stringify({
+                success: true,
+                agent: name,
+                output: result.trim()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to get agent info: ${error.message}`);
+        }
+    }
+});
+// Tool: Check for agent conflicts
+server.addTool({
+    name: 'agentic_flow_check_conflicts',
+    description: 'Check for conflicts between package agents and local custom agents. Identifies agents with the same relative path in both locations.',
+    parameters: z.object({}),
+    execute: async () => {
+        try {
+            const cmd = `npx --yes agentic-flow agent conflicts`;
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024,
+                timeout: 30000
+            });
+            return JSON.stringify({
+                success: true,
+                output: result.trim()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to check conflicts: ${error.message}`);
+        }
+    }
+});
+console.error('✅ Registered 6 tools:');
+console.error('   • agentic_flow_agent (execute agent)');
+console.error('   • agentic_flow_list_agents (list 66+ agents)');
+console.error('   • agentic_flow_create_agent (create custom agent)');
+console.error('   • agentic_flow_list_all_agents (list with sources)');
+console.error('   • agentic_flow_agent_info (get agent details)');
+console.error('   • agentic_flow_check_conflicts (conflict detection)');
 console.error('🔌 Starting stdio transport...');
 server.start({ transportType: 'stdio' }).then(() => {
     console.error('✅ Agentic-Flow MCP server running on stdio');

package/dist/utils/agentLoader.js

@@ -79,25 +79,70 @@ function findAgentFiles(dir) {
     return files;
 }
 /**
- * Load all agents from .claude/agents directory
+ * Load all agents from .claude/agents directory with deduplication
+ * Local agents (.claude/agents in CWD) override package agents
  */
 export function loadAgents(agentsDir) {
     const agents = new Map();
-    // Priority: explicit parameter > env var > package default > current working directory
-    const targetDir = agentsDir
-        || process.env.AGENTS_DIR
-        || (existsSync(defaultAgentsDir) ? defaultAgentsDir : join(process.cwd(), '.claude/agents'));
-    logger.info('Loading agents from directory', { agentsDir: targetDir });
-    const agentFiles = findAgentFiles(targetDir);
-    logger.debug('Found agent files', { count: agentFiles.length });
-    for (const filePath of agentFiles) {
-        const agent = parseAgentFile(filePath);
-        if (agent) {
-            agents.set(agent.name, agent);
-            logger.debug('Loaded agent', { name: agent.name, description: agent.description.substring(0, 100) });
+    const agentsByRelativePath = new Map();
+    // If explicit directory is provided, use only that
+    if (agentsDir) {
+        logger.info('Loading agents from explicit directory', { agentsDir });
+        const agentFiles = findAgentFiles(agentsDir);
+        for (const filePath of agentFiles) {
+            const agent = parseAgentFile(filePath);
+            if (agent) {
+                agents.set(agent.name, agent);
+            }
+        }
+        return agents;
+    }
+    // Otherwise, load from both package and local with deduplication
+    const localAgentsDir = join(process.cwd(), '.claude/agents');
+    // 1. Load package agents first (if they exist)
+    if (existsSync(defaultAgentsDir)) {
+        logger.info('Loading package agents', { agentsDir: defaultAgentsDir });
+        const packageFiles = findAgentFiles(defaultAgentsDir);
+        logger.debug('Found package agent files', { count: packageFiles.length });
+        for (const filePath of packageFiles) {
+            const agent = parseAgentFile(filePath);
+            if (agent) {
+                const relativePath = filePath.substring(defaultAgentsDir.length + 1);
+                agentsByRelativePath.set(relativePath, agent);
+                agents.set(agent.name, agent);
+                logger.debug('Loaded package agent', { name: agent.name, path: relativePath });
+            }
+        }
+    }
+    // 2. Load local agents (override package agents with same relative path)
+    if (existsSync(localAgentsDir) && localAgentsDir !== defaultAgentsDir) {
+        logger.info('Loading local agents', { agentsDir: localAgentsDir });
+        const localFiles = findAgentFiles(localAgentsDir);
+        logger.debug('Found local agent files', { count: localFiles.length });
+        for (const filePath of localFiles) {
+            const agent = parseAgentFile(filePath);
+            if (agent) {
+                const relativePath = filePath.substring(localAgentsDir.length + 1);
+                const existingAgent = agentsByRelativePath.get(relativePath);
+                if (existingAgent) {
+                    logger.info('Local agent overrides package agent', {
+                        name: agent.name,
+                        path: relativePath
+                    });
+                    // Remove old agent
+                    agents.delete(existingAgent.name);
+                }
+                agentsByRelativePath.set(relativePath, agent);
+                agents.set(agent.name, agent);
+                logger.debug('Loaded local agent', { name: agent.name, path: relativePath });
+            }
         }
     }
-    logger.info('Agents loaded successfully', { count: agents.size });
+    logger.info('Agents loaded successfully', {
+        total: agents.size,
+        package: existsSync(defaultAgentsDir) ? findAgentFiles(defaultAgentsDir).length : 0,
+        local: existsSync(localAgentsDir) ? findAgentFiles(localAgentsDir).length : 0
+    });
     return agents;
 }
 /**

package/dist/utils/cli.js

@@ -16,6 +16,11 @@ export function parseArgs() {
         options.mode = 'config';
         return options;
     }
+    // Check for agent management command
+    if (args[0] === 'agent') {
+        options.mode = 'agent-manager';
+        return options;
+    }
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         switch (arg) {
@@ -48,6 +53,38 @@ export function parseArgs() {
             case '-l':
                 options.mode = 'list';
                 break;
+            // API Configuration
+            case '--anthropic-key':
+                options.anthropicApiKey = args[++i];
+                break;
+            case '--openrouter-key':
+                options.openrouterApiKey = args[++i];
+                break;
+            // Agent Behavior
+            case '--temperature':
+                options.temperature = parseFloat(args[++i]);
+                break;
+            case '--max-tokens':
+                options.maxTokens = parseInt(args[++i], 10);
+                break;
+            // Directory Configuration
+            case '--agents-dir':
+                options.agentsDir = args[++i];
+                break;
+            // Output Options
+            case '--output':
+                options.outputFormat = args[++i];
+                break;
+            case '--verbose':
+                options.verbose = true;
+                break;
+            // Execution Control
+            case '--timeout':
+                options.timeout = parseInt(args[++i], 10);
+                break;
+            case '--retry':
+                options.retryOnError = true;
+                break;
         }
     }
     return options;
@@ -61,6 +98,8 @@ USAGE:
 
 COMMANDS:
   mcp <command> [server]  Manage MCP servers (start, stop, status, list)
+  config [command]        Configuration wizard (set, get, list, delete, reset)
+  agent <command>         Agent management (list, create, info, conflicts)
   --list, -l              List all available agents
   --agent, -a <name>      Run specific agent mode
   (default)               Run parallel mode (3 agents)
@@ -74,28 +113,67 @@ MCP COMMANDS:
   Available servers: claude-flow, flow-nexus, agentic-payments, all (default)
 
 OPTIONS:
-  --task, -t <task>       Task description for agent mode
-  --model, -m <model>     Model to use (supports OpenRouter models)
-  --provider, -p <name>   Provider to use (anthropic, openrouter, onnx)
-  --stream, -s            Enable real-time streaming output
-  --help, -h              Show this help message
+  --task, -t <task>           Task description for agent mode
+  --model, -m <model>         Model to use (supports OpenRouter models)
+  --provider, -p <name>       Provider (anthropic, openrouter, onnx)
+  --stream, -s                Enable real-time streaming output
+
+  API CONFIGURATION:
+  --anthropic-key <key>       Override ANTHROPIC_API_KEY
+  --openrouter-key <key>      Override OPENROUTER_API_KEY
+
+  AGENT BEHAVIOR:
+  --temperature <0.0-1.0>     Sampling temperature (creativity)
+  --max-tokens <number>       Maximum response tokens
+
+  DIRECTORY:
+  --agents-dir <path>         Custom agents directory
+
+  OUTPUT:
+  --output <text|json|md>     Output format
+  --verbose                   Enable verbose logging
+
+  EXECUTION:
+  --timeout <ms>              Execution timeout
+  --retry                     Auto-retry on errors
+
+  --help, -h                  Show this help message
 
 EXAMPLES:
+  # Agent Management
+  npx agentic-flow agent list             # List all agents with sources
+  npx agentic-flow agent create           # Interactive agent creator
+  npx agentic-flow agent info coder       # Get agent details
+  npx agentic-flow agent conflicts        # Check for conflicts
+
+  # Configuration
+  npx agentic-flow config                 # Interactive config wizard
+  npx agentic-flow config set PROVIDER openrouter
+  npx agentic-flow config list            # View all settings
+
   # MCP Server Management
   npx agentic-flow mcp start              # Start all MCP servers
-  npx agentic-flow mcp start claude-flow  # Start specific server
-  npx agentic-flow mcp list               # List all 203+ MCP tools
-  npx agentic-flow mcp status             # Check server status
+  npx agentic-flow mcp list               # List all 209+ MCP tools
+
+  # Agent Execution (Basic)
+  npx agentic-flow --list                 # List all agents
+  npx agentic-flow --agent coder --task "Build REST API"
+
+  # Agent Execution (Advanced)
+  npx agentic-flow --agent coder --task "Build API" \\
+    --provider openrouter \\
+    --model "meta-llama/llama-3.1-8b-instruct" \\
+    --temperature 0.7 \\
+    --max-tokens 2000 \\
+    --output json \\
+    --verbose
 
-  # Agent Execution
-  npx agentic-flow --list                 # List all 150+ agents
-  npx agentic-flow --agent researcher --task "Analyze AI trends"
-  npx agentic-flow --agent coder --task "Build REST API" --model "meta-llama/llama-3.1-8b-instruct"
-  npx agentic-flow --agent coder --task "Create hello world" --provider onnx
-  npx agentic-flow --agent coder --task "Build REST API" --stream
+  # Agent Execution (Custom)
+  npx agentic-flow --agent my-custom-agent --task "Your task" \\
+    --agents-dir ./my-agents
 
   # Parallel Mode
-  npx agentic-flow  # Run 3 agents in parallel (requires TOPIC, DIFF, DATASET)
+  npx agentic-flow  # Run 3 agents in parallel
 
 ENVIRONMENT VARIABLES:
   ANTHROPIC_API_KEY       Anthropic API key (for Claude models)
@@ -111,11 +189,11 @@ ENVIRONMENT VARIABLES:
   ENABLE_STREAMING        Enable streaming (true/false)
   HEALTH_PORT             Health check port (default: 8080)
 
-MCP TOOLS (203+ available):
-  • claude-flow-sdk: 6 in-process tools (memory, swarm coordination)
+MCP TOOLS (209+ available):
+  • agentic-flow: 6 tools (agent execution, creation, management)
   • claude-flow: 101 tools (neural networks, GitHub, workflows, DAA)
   • flow-nexus: 96 cloud tools (sandboxes, distributed swarms, templates)
-  • agentic-payments: Payment authorization and multi-agent consensus
+  • agentic-payments: 6 tools (payment authorization, multi-agent consensus)
 
 For more information, visit: https://github.com/ruvnet/agentic-flow
   `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-flow",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Production-ready AI agent orchestration platform with 66 specialized agents, 111 MCP tools, and autonomous multi-agent swarms. Built by @ruvnet with Claude Agent SDK, neural networks, memory persistence, GitHub integration, and distributed consensus protocols.",
   "type": "module",
   "main": "dist/index.js",