agentic-flow 1.1.1 → 1.1.3

package/dist/router/router.js

@@ -5,6 +5,7 @@ import { join } from 'path';
 import { OpenRouterProvider } from './providers/openrouter.js';
 import { AnthropicProvider } from './providers/anthropic.js';
 import { ONNXLocalProvider } from './providers/onnx-local.js';
+import { GeminiProvider } from './providers/gemini.js';
 export class ModelRouter {
     config;
     providers = new Map();
@@ -20,6 +21,7 @@ export class ModelRouter {
             process.env.AGENTIC_FLOW_ROUTER_CONFIG,
             join(homedir(), '.agentic-flow', 'router.config.json'),
             join(process.cwd(), 'router.config.json'),
+            join(process.cwd(), 'config', 'router.config.json'),
             join(process.cwd(), 'router.config.example.json')
         ].filter(Boolean);
         for (const path of paths) {
@@ -30,7 +32,43 @@ export class ModelRouter {
                 return this.substituteEnvVars(config);
             }
         }
-        throw new Error('No router configuration file found');
+        // If no config file found, create config from environment variables
+        return this.createConfigFromEnv();
+    }
+    createConfigFromEnv() {
+        // Create minimal config from environment variables
+        const config = {
+            version: '1.0',
+            defaultProvider: process.env.PROVIDER || 'anthropic',
+            routing: { mode: 'manual' },
+            providers: {}
+        };
+        // Add Anthropic if API key exists
+        if (process.env.ANTHROPIC_API_KEY) {
+            config.providers.anthropic = {
+                apiKey: process.env.ANTHROPIC_API_KEY,
+                baseUrl: process.env.ANTHROPIC_BASE_URL
+            };
+        }
+        // Add OpenRouter if API key exists
+        if (process.env.OPENROUTER_API_KEY) {
+            config.providers.openrouter = {
+                apiKey: process.env.OPENROUTER_API_KEY,
+                baseUrl: process.env.OPENROUTER_BASE_URL
+            };
+        }
+        // Add Gemini if API key exists
+        if (process.env.GOOGLE_GEMINI_API_KEY) {
+            config.providers.gemini = {
+                apiKey: process.env.GOOGLE_GEMINI_API_KEY
+            };
+        }
+        // ONNX is always available (no API key needed)
+        config.providers.onnx = {
+            modelPath: process.env.ONNX_MODEL_PATH,
+            executionProviders: ['cpu']
+        };
+        return config;
     }
     substituteEnvVars(obj) {
         if (typeof obj === 'string') {
@@ -53,15 +91,18 @@ export class ModelRouter {
         return obj;
     }
     initializeProviders() {
+        const verbose = process.env.ROUTER_VERBOSE === 'true';
         // Initialize Anthropic
         if (this.config.providers.anthropic) {
             try {
                 const provider = new AnthropicProvider(this.config.providers.anthropic);
                 this.providers.set('anthropic', provider);
-                console.log('✅ Anthropic provider initialized');
+                if (verbose)
+                    console.log('✅ Anthropic provider initialized');
             }
             catch (error) {
-                console.error('❌ Failed to initialize Anthropic:', error);
+                if (verbose)
+                    console.error('❌ Failed to initialize Anthropic:', error);
             }
         }
         // Initialize OpenRouter
@@ -69,10 +110,12 @@ export class ModelRouter {
             try {
                 const provider = new OpenRouterProvider(this.config.providers.openrouter);
                 this.providers.set('openrouter', provider);
-                console.log('✅ OpenRouter provider initialized');
+                if (verbose)
+                    console.log('✅ OpenRouter provider initialized');
             }
             catch (error) {
-                console.error('❌ Failed to initialize OpenRouter:', error);
+                if (verbose)
+                    console.error('❌ Failed to initialize OpenRouter:', error);
             }
         }
         // Initialize ONNX Local
@@ -85,10 +128,25 @@ export class ModelRouter {
                     temperature: this.config.providers.onnx.temperature || 0.7
                 });
                 this.providers.set('onnx', provider);
-                console.log('✅ ONNX Local provider initialized');
+                if (verbose)
+                    console.log('✅ ONNX Local provider initialized');
+            }
+            catch (error) {
+                if (verbose)
+                    console.error('❌ Failed to initialize ONNX:', error);
+            }
+        }
+        // Initialize Gemini
+        if (this.config.providers.gemini) {
+            try {
+                const provider = new GeminiProvider(this.config.providers.gemini);
+                this.providers.set('gemini', provider);
+                if (verbose)
+                    console.log('✅ Gemini provider initialized');
             }
             catch (error) {
-                console.error('❌ Failed to initialize ONNX:', error);
+                if (verbose)
+                    console.error('❌ Failed to initialize Gemini:', error);
             }
         }
         // TODO: Initialize other providers (OpenAI, Ollama, LiteLLM)

package/dist/utils/logger.js

@@ -26,6 +26,10 @@ class Logger {
         }
     }
     debug(message, data) {
+        // Skip debug logs unless DEBUG or VERBOSE environment variable is set
+        if (!process.env.DEBUG && !process.env.VERBOSE) {
+            return;
+        }
         this.log('debug', message, data);
     }
     info(message, data) {

package/dist/utils/modelOptimizer.js

@@ -51,29 +51,29 @@ const MODEL_DATABASE = {
     // Tier 2: Cost-Effective Champions
     'deepseek-r1': {
         provider: 'openrouter',
-        model: 'deepseek/deepseek-r1',
+        model: 'deepseek/deepseek-r1-0528:free',
         modelName: 'DeepSeek R1',
-        cost_per_1m_input: 0.55,
-        cost_per_1m_output: 2.19,
+        cost_per_1m_input: 0.00,
+        cost_per_1m_output: 0.00,
         quality_score: 90,
         speed_score: 80,
-        cost_score: 85,
+        cost_score: 100,
         tier: 'cost-effective',
-        strengths: ['reasoning', 'coding', 'math', 'value'],
+        strengths: ['reasoning', 'coding', 'math', 'value', 'free'],
         weaknesses: ['newer-model'],
         bestFor: ['coder', 'pseudocode', 'specification', 'refinement', 'tester']
     },
     'deepseek-chat-v3': {
         provider: 'openrouter',
-        model: 'deepseek/deepseek-chat',
-        modelName: 'DeepSeek Chat V3',
-        cost_per_1m_input: 0.14,
-        cost_per_1m_output: 0.28,
+        model: 'deepseek/deepseek-chat-v3.1:free',
+        modelName: 'DeepSeek Chat V3.1',
+        cost_per_1m_input: 0.00,
+        cost_per_1m_output: 0.00,
         quality_score: 82,
         speed_score: 90,
-        cost_score: 98,
+        cost_score: 100,
         tier: 'cost-effective',
-        strengths: ['cost', 'speed', 'coding', 'development'],
+        strengths: ['cost', 'speed', 'coding', 'development', 'free'],
         weaknesses: ['complex-reasoning'],
         bestFor: ['coder', 'reviewer', 'tester', 'backend-dev', 'cicd-engineer']
     },
@@ -92,19 +92,19 @@ const MODEL_DATABASE = {
         weaknesses: ['quality'],
         bestFor: ['researcher', 'planner', 'smart-agent']
     },
-    'llama-3-3-70b': {
+    'llama-3-3-8b': {
         provider: 'openrouter',
-        model: 'meta-llama/llama-3.3-70b-instruct',
-        modelName: 'Llama 3.3 70B',
-        cost_per_1m_input: 0.35,
-        cost_per_1m_output: 0.40,
-        quality_score: 80,
-        speed_score: 85,
-        cost_score: 90,
+        model: 'meta-llama/llama-3.3-8b-instruct:free',
+        modelName: 'Llama 3.3 8B',
+        cost_per_1m_input: 0.00,
+        cost_per_1m_output: 0.00,
+        quality_score: 72,
+        speed_score: 95,
+        cost_score: 100,
         tier: 'balanced',
-        strengths: ['open-source', 'versatile', 'coding'],
-        weaknesses: ['verbosity'],
-        bestFor: ['coder', 'reviewer', 'base-template-generator']
+        strengths: ['open-source', 'versatile', 'coding', 'free', 'fast'],
+        weaknesses: ['smaller-model'],
+        bestFor: ['coder', 'reviewer', 'base-template-generator', 'tester']
     },
     'qwen-2-5-72b': {
         provider: 'openrouter',

package/docs/PACKAGE_STRUCTURE.md

@@ -0,0 +1,199 @@
+# agentic-flow Package Structure
+
+## Overview
+
+The `agentic-flow` npm package includes all necessary files for agent execution, including 76 pre-built agent definitions in the `.claude/agents/` directory.
+
+## Package Contents
+
+When you install `agentic-flow` via npm, you get:
+
+```
+agentic-flow/
+├── dist/                    # Compiled JavaScript
+│   ├── cli-proxy.js         # Main CLI entry point
+│   ├── agents/              # Agent implementations
+│   ├── router/              # Multi-provider router
+│   └── utils/               # Utilities
+├── .claude/                 # Agent definitions (76 files)
+│   └── agents/
+│       ├── core/            # Core agents (coder, planner, reviewer, etc.)
+│       ├── consensus/       # Distributed consensus agents
+│       ├── github/          # GitHub integration agents
+│       ├── flow-nexus/      # Flow Nexus cloud agents
+│       ├── sparc/           # SPARC methodology agents
+│       └── ...              # More specialized categories
+├── docs/                    # Documentation
+├── README.md
+└── LICENSE
+```
+
+## Agent Loading System
+
+### Package Agents (Bundled)
+
+All 76 agent definitions are included in the npm package at:
+```
+node_modules/agentic-flow/.claude/agents/
+```
+
+These are automatically loaded when you run `npx agentic-flow`.
+
+### Local Agents (User Custom)
+
+You can create custom agents in your project:
+```
+your-project/
+└── .claude/
+    └── agents/
+        └── custom/
+            └── my-agent.md
+```
+
+**Local agents override package agents** with the same relative path.
+
+## Agent Discovery Order
+
+1. **Package agents**: Load from `node_modules/agentic-flow/.claude/agents/`
+2. **Local agents**: Load from `./claude/agents/` (overrides package agents if same path)
+3. **Custom directory**: Use `--agents-dir` flag to specify alternative location
+
+## Verification
+
+To verify your installation includes all agents:
+
+```bash
+# List all available agents
+npx agentic-flow --list
+
+# Should show 73 agents (76 files, some without proper frontmatter)
+```
+
+## Custom Agent Creation
+
+Create custom agents that augment or replace package agents:
+
+```bash
+# Interactive creation
+npx agentic-flow agent create
+
+# Manual creation
+mkdir -p .claude/agents/custom
+cat > .claude/agents/custom/my-agent.md << 'EOF'
+---
+name: my-agent
+description: My custom agent
+---
+
+You are a specialized agent for [purpose].
+Follow these guidelines:
+- [guideline 1]
+- [guideline 2]
+EOF
+```
+
+## Package Maintenance
+
+### Building
+
+```bash
+npm run build
+```
+
+### Verifying Package Structure
+
+```bash
+./scripts/verify-package.sh
+```
+
+### Creating Package
+
+```bash
+npm pack
+```
+
+### Testing Installation
+
+```bash
+# Install in test directory
+mkdir -p /tmp/test-install
+cd /tmp/test-install
+npm install /path/to/agentic-flow-1.1.2.tgz
+
+# Verify agents loaded
+./node_modules/.bin/agentic-flow --list
+```
+
+## Environment Configuration
+
+The package automatically loads `.env` files from:
+1. Current directory
+2. Parent directories (recursively up to root)
+
+This ensures API keys work from any directory:
+
+```bash
+# Works from project root
+cd /workspaces/myproject
+npx agentic-flow --agent coder --task "test" --provider gemini
+
+# Also works from subdirectory (finds parent .env)
+cd /workspaces/myproject/src
+npx agentic-flow --agent coder --task "test" --provider gemini
+```
+
+## Files Included in Package
+
+See `package.json`:
+```json
+{
+  "files": [
+    "dist",
+    "docs",
+    ".claude",
+    "README.md",
+    "LICENSE"
+  ]
+}
+```
+
+## Files Excluded (.npmignore)
+
+- Source files (`src/`, `*.ts`)
+- Tests (`tests/`, `validation/`)
+- Development files (`.env`, `tsconfig.json`)
+- Runtime state directories (`.claude-flow/`, `.swarm/`, `memory/`)
+- ONNX models (`*.onnx`, `models/`)
+
+## Agent Categories
+
+The 76 included agents span:
+
+- **Core** (5): coder, planner, researcher, reviewer, tester
+- **Consensus** (7): Byzantine, CRDT, Gossip, Raft, Quorum, etc.
+- **GitHub** (14): PR management, issue tracking, release automation
+- **Flow Nexus** (9): Cloud sandboxes, neural networks, workflows
+- **SPARC** (4): Specification, Pseudocode, Architecture, Refinement
+- **Optimization** (5): Resource allocation, load balancing, benchmarks
+- **Goal Planning** (2): GOAP, sublinear algorithms
+- **Swarm** (3): Hierarchical, mesh, adaptive coordination
+- **Payments** (1): Agentic payment authorization
+- **Templates** (10): Automation, orchestration, migration
+- **Testing** (2): TDD, production validation
+- **Specialized** (varies): Analysis, architecture, data, development, DevOps, documentation
+
+## Total Agent Count
+
+- **76 agent files** in `.claude/agents/`
+- **73 valid agents** (3 files missing required frontmatter)
+- **All core agents** (coder, planner, researcher, reviewer, tester) working
+
+## Summary
+
+✅ All 76 agent definitions are packaged and distributed via npm
+✅ Agent loading works automatically from `node_modules/`
+✅ Local `.claude/agents/` can override package agents
+✅ Environment variable loading works recursively
+✅ Package structure verified and tested
+
+The `.claude/` directory is a first-class part of the npm package, ensuring all users have immediate access to the complete agent library upon installation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-flow",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "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",
@@ -110,6 +110,7 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.1.5",
     "@anthropic-ai/sdk": "^0.65.0",
+    "@google/genai": "^1.22.0",
     "agentic-payments": "^0.1.3",
     "axios": "^1.12.2",
     "claude-flow": "^2.0.0",

package/.claude/commands/coordination/README.md

@@ -1,9 +0,0 @@
-# Coordination Commands
-
-Commands for coordination operations in Claude Flow.
-
-## Available Commands
-
-- [swarm-init](./swarm-init.md)
-- [agent-spawn](./agent-spawn.md)
-- [task-orchestrate](./task-orchestrate.md)

package/.claude/commands/coordination/agent-spawn.md

@@ -1,25 +0,0 @@
-# agent-spawn
-
-Spawn a new agent in the current swarm.
-
-## Usage
-```bash
-npx claude-flow agent spawn [options]
-```
-
-## Options
-- `--type <type>` - Agent type (coder, researcher, analyst, tester, coordinator)
-- `--name <name>` - Custom agent name
-- `--skills <list>` - Specific skills (comma-separated)
-
-## Examples
-```bash
-# Spawn coder agent
-npx claude-flow agent spawn --type coder
-
-# With custom name
-npx claude-flow agent spawn --type researcher --name "API Expert"
-
-# With specific skills
-npx claude-flow agent spawn --type coder --skills "python,fastapi,testing"
-```

package/.claude/commands/coordination/init.md

@@ -1,44 +0,0 @@
-# Initialize Coordination Framework
-
-## 🎯 Key Principle
-**This tool coordinates Claude Code's actions. It does NOT write code or create content.**
-
-## MCP Tool Usage in Claude Code
-
-**Tool:** `mcp__claude-flow__swarm_init`
-
-## Parameters
-```json
-{"topology": "mesh", "maxAgents": 5, "strategy": "balanced"}
-```
-
-## Description
-Set up a coordination topology to guide Claude Code's approach to complex tasks
-
-## Details
-This tool creates a coordination framework that helps Claude Code:
-- Break down complex problems systematically
-- Approach tasks from multiple perspectives
-- Maintain consistency across large projects
-- Work more efficiently through structured coordination
-
-Remember: This does NOT create actual coding agents. It creates a coordination pattern for Claude Code to follow.
-
-## Example Usage
-
-**In Claude Code:**
-1. Use the tool: `mcp__claude-flow__swarm_init`
-2. With parameters: `{"topology": "mesh", "maxAgents": 5, "strategy": "balanced"}`
-3. Claude Code then executes the coordinated plan using its native tools
-
-## Important Reminders
-- ✅ This tool provides coordination and structure
-- ✅ Claude Code performs all actual implementation
-- ❌ The tool does NOT write code
-- ❌ The tool does NOT access files directly
-- ❌ The tool does NOT execute commands
-
-## See Also
-- Main documentation: /claude.md
-- Other commands in this category
-- Workflow examples in /workflows/

package/.claude/commands/coordination/orchestrate.md

@@ -1,43 +0,0 @@
-# Coordinate Task Execution
-
-## 🎯 Key Principle
-**This tool coordinates Claude Code's actions. It does NOT write code or create content.**
-
-## MCP Tool Usage in Claude Code
-
-**Tool:** `mcp__claude-flow__task_orchestrate`
-
-## Parameters
-```json
-{"task": "Implement authentication system", "strategy": "parallel", "priority": "high"}
-```
-
-## Description
-Break down and coordinate complex tasks for systematic execution by Claude Code
-
-## Details
-Orchestration strategies:
-- **parallel**: Claude Code works on independent components simultaneously
-- **sequential**: Step-by-step execution for dependent tasks
-- **adaptive**: Dynamically adjusts based on task complexity
-
-The orchestrator creates a plan that Claude Code follows using its native tools.
-
-## Example Usage
-
-**In Claude Code:**
-1. Use the tool: `mcp__claude-flow__task_orchestrate`
-2. With parameters: `{"task": "Implement authentication system", "strategy": "parallel", "priority": "high"}`
-3. Claude Code then executes the coordinated plan using its native tools
-
-## Important Reminders
-- ✅ This tool provides coordination and structure
-- ✅ Claude Code performs all actual implementation
-- ❌ The tool does NOT write code
-- ❌ The tool does NOT access files directly
-- ❌ The tool does NOT execute commands
-
-## See Also
-- Main documentation: /claude.md
-- Other commands in this category
-- Workflow examples in /workflows/

package/.claude/commands/coordination/spawn.md

@@ -1,45 +0,0 @@
-# Create Cognitive Patterns
-
-## 🎯 Key Principle
-**This tool coordinates Claude Code's actions. It does NOT write code or create content.**
-
-## MCP Tool Usage in Claude Code
-
-**Tool:** `mcp__claude-flow__agent_spawn`
-
-## Parameters
-```json
-{"type": "researcher", "name": "Literature Analysis", "capabilities": ["deep-analysis"]}
-```
-
-## Description
-Define cognitive patterns that represent different approaches Claude Code can take
-
-## Details
-Agent types represent thinking patterns, not actual coders:
-- **researcher**: Systematic exploration approach
-- **coder**: Implementation-focused thinking
-- **analyst**: Data-driven decision making
-- **architect**: Big-picture system design
-- **reviewer**: Quality and consistency checking
-
-These patterns guide how Claude Code approaches different aspects of your task.
-
-## Example Usage
-
-**In Claude Code:**
-1. Use the tool: `mcp__claude-flow__agent_spawn`
-2. With parameters: `{"type": "researcher", "name": "Literature Analysis", "capabilities": ["deep-analysis"]}`
-3. Claude Code then executes the coordinated plan using its native tools
-
-## Important Reminders
-- ✅ This tool provides coordination and structure
-- ✅ Claude Code performs all actual implementation
-- ❌ The tool does NOT write code
-- ❌ The tool does NOT access files directly
-- ❌ The tool does NOT execute commands
-
-## See Also
-- Main documentation: /claude.md
-- Other commands in this category
-- Workflow examples in /workflows/

package/.claude/commands/coordination/swarm-init.md

@@ -1,85 +0,0 @@
-# swarm init
-
-Initialize a Claude Flow swarm with specified topology and configuration.
-
-## Usage
-
-```bash
-npx claude-flow swarm init [options]
-```
-
-## Options
-
-- `--topology, -t <type>` - Swarm topology: mesh, hierarchical, ring, star (default: hierarchical)
-- `--max-agents, -m <number>` - Maximum number of agents (default: 8)
-- `--strategy, -s <type>` - Execution strategy: balanced, parallel, sequential (default: parallel)
-- `--auto-spawn` - Automatically spawn agents based on task complexity
-- `--memory` - Enable cross-session memory persistence
-- `--github` - Enable GitHub integration features
-
-## Examples
-
-### Basic initialization
-
-```bash
-npx claude-flow swarm init
-```
-
-### Mesh topology for research
-
-```bash
-npx claude-flow swarm init --topology mesh --max-agents 5 --strategy balanced
-```
-
-### Hierarchical for development
-
-```bash
-npx claude-flow swarm init --topology hierarchical --max-agents 10 --strategy parallel --auto-spawn
-```
-
-### GitHub-focused swarm
-
-```bash
-npx claude-flow swarm init --topology star --github --memory
-```
-
-## Topologies
-
-### Mesh
-
-- All agents connect to all others
-- Best for: Research, exploration, brainstorming
-- Communication: High overhead, maximum information sharing
-
-### Hierarchical
-
-- Tree structure with clear command chain
-- Best for: Development, structured tasks, large projects
-- Communication: Efficient, clear responsibilities
-
-### Ring
-
-- Agents connect in a circle
-- Best for: Pipeline processing, sequential workflows
-- Communication: Low overhead, ordered processing
-
-### Star
-
-- Central coordinator with satellite agents
-- Best for: Simple tasks, centralized control
-- Communication: Minimal overhead, clear coordination
-
-## Integration with Claude Code
-
-Once initialized, use MCP tools in Claude Code:
-
-```javascript
-mcp__claude-flow__swarm_init { topology: "hierarchical", maxAgents: 8 }
-```
-
-## See Also
-
-- `agent spawn` - Create swarm agents
-- `task orchestrate` - Coordinate task execution
-- `swarm status` - Check swarm state
-- `swarm monitor` - Real-time monitoring