@sparkleideas/integration 3.0.2 → 3.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sparkleideas/integration",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "type": "module",
   "description": "Integration module - agentic-flow@alpha deep integration, ADR-001 compliance, TokenOptimizer",
   "main": "dist/index.js",
@@ -24,7 +24,7 @@
     "swarm"
   ],
   "peerDependencies": {
-    "@sparkleideas/agentic-flow": "^2.0.0-alpha"
+    "@sparkleideas/agentic-flow": "*"
   },
   "devDependencies": {
     "vitest": "^4.0.16"

package/src/__tests__/agent-adapter.test.ts

@@ -148,8 +148,8 @@ describe('AgentAdapter', () => {
     });
   });
 
-  describe('Agent Conversion from @sparkleideas/agentic-flow', () => {
-    it('should convert @sparkleideas/agentic-flow agent format', () => {
+  describe('Agent Conversion from agentic-flow', () => {
+    it('should convert agentic-flow agent format', () => {
       const mockAgenticFlowAgent = {
         id: 'mock-agent-1',
         name: 'Mock Agent',
@@ -190,8 +190,8 @@ describe('AgentAdapter', () => {
     });
   });
 
-  describe('Agent Conversion to @sparkleideas/agentic-flow', () => {
-    it('should convert Claude Flow agent to @sparkleideas/agentic-flow format', async () => {
+  describe('Agent Conversion to agentic-flow', () => {
+    it('should convert Claude Flow agent to agentic-flow format', async () => {
       const agent = await adapter.createWithDelegation({
         id: 'convert-agent',
         name: 'Convert Test',
@@ -221,7 +221,7 @@ describe('AgentAdapter', () => {
         priority: 1,
       });
 
-      // Note: isDelegated will be false unless @sparkleideas/agentic-flow is actually available
+      // Note: isDelegated will be false unless agentic-flow is actually available
       const isDelegated = adapter.isDelegated('delegation-check-agent');
 
       expect(typeof isDelegated).toBe('boolean');

package/src/__tests__/token-optimizer.test.ts

@@ -1,6 +1,6 @@
 /**
  * Token Optimizer Integration Tests
- * Validates @sparkleideas/agentic-flow Agent Booster integration
+ * Validates agentic-flow Agent Booster integration
  */
 
 import { describe, it, expect, beforeAll } from 'vitest';
@@ -23,9 +23,9 @@ describe('TokenOptimizer', () => {
       expect(typeof stats.agenticFlowAvailable).toBe('boolean');
     });
 
-    it('should detect @sparkleideas/agentic-flow availability', async () => {
+    it('should detect agentic-flow availability', async () => {
       const stats = optimizer.getStats();
-      // @sparkleideas/agentic-flow is installed in v3/node_modules
+      // agentic-flow is installed in v3/node_modules
       expect(stats.agenticFlowAvailable).toBe(true);
     });
   });

package/src/agent-adapter.ts

@@ -1,11 +1,11 @@
 /**
- * AgentAdapter - Bridge between Claude Flow and @sparkleideas/agentic-flow Agents
+ * AgentAdapter - Bridge between Claude Flow and agentic-flow Agents
  *
  * Provides bidirectional conversion and delegation patterns between:
  * - Claude Flow v3 DDD agent architecture
- * - @sparkleideas/agentic-flow's optimized agent implementations
+ * - agentic-flow's optimized agent implementations
  *
- * This implements ADR-001: Adopt @sparkleideas/agentic-flow as Core Foundation
+ * This implements ADR-001: Adopt agentic-flow as Core Foundation
  * by providing clean conversion and delegation patterns.
  *
  * Pattern follows existing adapters:
@@ -31,8 +31,8 @@ import {
 } from './agentic-flow-agent.js';
 
 /**
- * Interface for @sparkleideas/agentic-flow Agent (external package)
- * This represents the expected API from @sparkleideas/agentic-flow's Agent class
+ * Interface for agentic-flow Agent (external package)
+ * This represents the expected API from agentic-flow's Agent class
  */
 interface AgenticFlowAgent_External {
   id: string;
@@ -60,7 +60,7 @@ interface AgenticFlowAgent_External {
  * Adapter configuration
  */
 export interface AgentAdapterConfig {
-  /** Enable bidirectional sync with @sparkleideas/agentic-flow */
+  /** Enable bidirectional sync with agentic-flow */
   enableSync: boolean;
   /** Auto-convert agent formats */
   autoConvert: boolean;
@@ -85,13 +85,13 @@ export interface AgentConversionResult {
 }
 
 /**
- * AgentAdapter - Bridges Claude Flow and @sparkleideas/agentic-flow agents
+ * AgentAdapter - Bridges Claude Flow and agentic-flow agents
  *
  * This adapter provides:
  * 1. Format conversion between agent representations
  * 2. Delegation management for optimized operations
  * 3. Bidirectional synchronization of agent state
- * 4. Fallback handling when @sparkleideas/agentic-flow is unavailable
+ * 4. Fallback handling when agentic-flow is unavailable
  *
  * Usage:
  * ```typescript
@@ -103,10 +103,10 @@ export interface AgentConversionResult {
  *
  * await adapter.initialize();
  *
- * // Convert @sparkleideas/agentic-flow agent to Claude Flow agent
+ * // Convert agentic-flow agent to Claude Flow agent
  * const { agent, success } = adapter.fromAgenticFlow(agenticFlowAgent);
  *
- * // Create Claude Flow agent with @sparkleideas/agentic-flow delegation
+ * // Create Claude Flow agent with agentic-flow delegation
  * const delegatedAgent = await adapter.createWithDelegation({
  *   id: 'agent-1',
  *   name: 'Coder',
@@ -124,7 +124,7 @@ export class AgentAdapter extends EventEmitter {
   private delegationMap: Map<string, AgenticFlowAgent_External> = new Map();
 
   /**
-   * Reference to @sparkleideas/agentic-flow core for accessing Agent factory
+   * Reference to agentic-flow core for accessing Agent factory
    */
   private agenticFlowCore: any = null;
 
@@ -150,7 +150,7 @@ export class AgentAdapter extends EventEmitter {
     this.emit('initializing');
 
     try {
-      // Attempt to load @sparkleideas/agentic-flow for delegation
+      // Attempt to load agentic-flow for delegation
       await this.connectToAgenticFlow();
 
       this.initialized = true;
@@ -185,12 +185,12 @@ export class AgentAdapter extends EventEmitter {
   }
 
   /**
-   * Convert @sparkleideas/agentic-flow agent to Claude Flow AgenticFlowAgent
+   * Convert agentic-flow agent to Claude Flow AgenticFlowAgent
    *
    * This method creates a Claude Flow agent wrapper around an existing
-   * @sparkleideas/agentic-flow agent instance, enabling delegation and integration.
+   * agentic-flow agent instance, enabling delegation and integration.
    *
-   * @param agenticFlowAgent - @sparkleideas/agentic-flow agent instance
+   * @param agenticFlowAgent - agentic-flow agent instance
    * @returns Conversion result with wrapped agent
    */
   fromAgenticFlow(
@@ -200,7 +200,7 @@ export class AgentAdapter extends EventEmitter {
     const unmappedFields: string[] = [];
 
     try {
-      // Map @sparkleideas/agentic-flow config to Claude Flow config
+      // Map agentic-flow config to Claude Flow config
       const config: AgentConfig = {
         id: agenticFlowAgent.id,
         name: agenticFlowAgent.name,
@@ -277,13 +277,13 @@ export class AgentAdapter extends EventEmitter {
   }
 
   /**
-   * Convert Claude Flow AgenticFlowAgent to @sparkleideas/agentic-flow format
+   * Convert Claude Flow AgenticFlowAgent to agentic-flow format
    *
    * This exports the agent configuration in a format compatible with
-   * @sparkleideas/agentic-flow's Agent constructor/factory.
+   * agentic-flow's Agent constructor/factory.
    *
    * @param agent - Claude Flow agent instance
-   * @returns @sparkleideas/agentic-flow compatible configuration
+   * @returns agentic-flow compatible configuration
    */
   toAgenticFlow(agent: AgenticFlowAgent): Record<string, unknown> {
     return {
@@ -307,12 +307,12 @@ export class AgentAdapter extends EventEmitter {
   }
 
   /**
-   * Create a Claude Flow agent with @sparkleideas/agentic-flow delegation
+   * Create a Claude Flow agent with agentic-flow delegation
    *
    * This is the primary method for creating agents in v3 with
-   * automatic delegation to @sparkleideas/agentic-flow when available.
+   * automatic delegation to agentic-flow when available.
    *
-   * ADR-001: Eliminates duplicate code by delegating to @sparkleideas/agentic-flow
+   * ADR-001: Eliminates duplicate code by delegating to agentic-flow
    * for core agent operations when the package is available.
    *
    * @param config - Agent configuration
@@ -326,7 +326,7 @@ export class AgentAdapter extends EventEmitter {
       enableDelegation: true,
     });
 
-    // If @sparkleideas/agentic-flow is available, create delegation reference
+    // If agentic-flow is available, create delegation reference
     if (this.agenticFlowCore && this.agenticFlowCore.createAgent) {
       try {
         const agenticFlowAgent = await this.agenticFlowCore.createAgent({
@@ -400,7 +400,7 @@ export class AgentAdapter extends EventEmitter {
   }
 
   /**
-   * Check if an agent is delegated to @sparkleideas/agentic-flow
+   * Check if an agent is delegated to agentic-flow
    */
   isDelegated(agentId: string): boolean {
     return this.delegationMap.has(agentId);
@@ -437,13 +437,13 @@ export class AgentAdapter extends EventEmitter {
   // ===== Private Methods =====
 
   /**
-   * Connect to @sparkleideas/agentic-flow package dynamically
+   * Connect to agentic-flow package dynamically
    */
   private async connectToAgenticFlow(): Promise<void> {
     try {
       // Dynamic import to handle optional dependency
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const agenticFlowModule: any = await import('@sparkleideas/agentic-flow').catch(() => null);
+      const agenticFlowModule: any = await import('agentic-flow').catch(() => null);
 
       if (agenticFlowModule && typeof agenticFlowModule.createAgenticFlow === 'function') {
         this.agenticFlowCore = await agenticFlowModule.createAgenticFlow({});
@@ -452,7 +452,7 @@ export class AgentAdapter extends EventEmitter {
           version: this.agenticFlowCore.version,
         });
 
-        this.logDebug('Connected to @sparkleideas/agentic-flow', {
+        this.logDebug('Connected to agentic-flow', {
           version: this.agenticFlowCore.version,
         });
       } else {
@@ -460,19 +460,19 @@ export class AgentAdapter extends EventEmitter {
         this.emit('agentic-flow-unavailable', {
           reason: 'package not found or incompatible',
         });
-        this.logDebug('@sparkleideas/agentic-flow not available, using local implementations');
+        this.logDebug('agentic-flow not available, using local implementations');
       }
     } catch (error) {
       this.agenticFlowCore = null;
       this.emit('agentic-flow-connection-failed', {
         error: (error as Error).message,
       });
-      this.logDebug('@sparkleideas/agentic-flow connection failed', error);
+      this.logDebug('agentic-flow connection failed', error);
     }
   }
 
   /**
-   * Map @sparkleideas/agentic-flow agent type to Claude Flow AgentType
+   * Map agentic-flow agent type to Claude Flow AgentType
    */
   private mapAgentType(type: string, warnings: string[]): AgentType | string {
     // Known valid agent types that pass through directly
@@ -517,7 +517,7 @@ export class AgentAdapter extends EventEmitter {
   }
 
   /**
-   * Extract capabilities from @sparkleideas/agentic-flow config
+   * Extract capabilities from agentic-flow config
    */
   private extractCapabilities(
     config: Record<string, unknown>,
@@ -562,13 +562,13 @@ export class AgentAdapter extends EventEmitter {
   }
 
   /**
-   * Sync status between Claude Flow and @sparkleideas/agentic-flow agents
+   * Sync status between Claude Flow and agentic-flow agents
    */
   private syncStatus(
     agent: AgenticFlowAgent,
     agenticFlowAgent: AgenticFlowAgent_External
   ): void {
-    // Map @sparkleideas/agentic-flow status to Claude Flow status
+    // Map agentic-flow status to Claude Flow status
     const statusMap: Record<string, AgentStatus> = {
       'initializing': 'spawning',
       'ready': 'idle',

package/src/agentic-flow-agent.ts

@@ -1,15 +1,15 @@
 /**
- * AgenticFlowAgent - Claude Flow Agent with @sparkleideas/agentic-flow Delegation
+ * AgenticFlowAgent - Claude Flow Agent with agentic-flow Delegation
  *
- * Per ADR-001: "Use @sparkleideas/agentic-flow's Agent base class for all agents"
- * This class wraps @sparkleideas/agentic-flow functionality while adding Claude Flow specifics.
+ * Per ADR-001: "Use agentic-flow's Agent base class for all agents"
+ * This class wraps agentic-flow functionality while adding Claude Flow specifics.
  *
  * This implements the adapter pattern to bridge between:
  * - Claude Flow's agent lifecycle (v3 DDD architecture)
- * - @sparkleideas/agentic-flow's optimized agent implementations
+ * - agentic-flow's optimized agent implementations
  *
- * When @sparkleideas/agentic-flow is available, this class delegates core operations to
- * @sparkleideas/agentic-flow's Agent implementations, eliminating 10,000+ lines of duplicate code.
+ * When agentic-flow is available, this class delegates core operations to
+ * agentic-flow's Agent implementations, eliminating 10,000+ lines of duplicate code.
  *
  * Performance Benefits:
  * - Flash Attention: 2.49x-7.47x speedup for context processing
@@ -189,8 +189,8 @@ export interface AgentHealth {
 }
 
 /**
- * Interface for @sparkleideas/agentic-flow Agent reference (for delegation)
- * This represents the @sparkleideas/agentic-flow Agent class API
+ * Interface for agentic-flow Agent reference (for delegation)
+ * This represents the agentic-flow Agent class API
  */
 interface AgenticFlowAgentReference {
   id: string;
@@ -208,9 +208,9 @@ interface AgenticFlowAgentReference {
  * AgenticFlowAgent Configuration
  */
 export interface AgentConfig extends IAgentConfig {
-  /** Enable delegation to @sparkleideas/agentic-flow */
+  /** Enable delegation to agentic-flow */
   enableDelegation?: boolean;
-  /** @sparkleideas/agentic-flow specific configuration */
+  /** agentic-flow specific configuration */
   agenticFlowConfig?: Record<string, unknown>;
 }
 
@@ -218,7 +218,7 @@ export interface AgentConfig extends IAgentConfig {
  * AgenticFlowAgent - Base class for all Claude Flow v3 agents
  *
  * This class serves as the foundation for all agent types in Claude Flow v3,
- * implementing ADR-001 by delegating to @sparkleideas/agentic-flow when available while
+ * implementing ADR-001 by delegating to agentic-flow when available while
  * maintaining backward compatibility with local implementations.
  *
  * Usage:
@@ -285,13 +285,13 @@ export class AgenticFlowAgent extends EventEmitter implements IAgent {
   private totalTaskDuration: number = 0;
 
   /**
-   * Reference to @sparkleideas/agentic-flow Agent for delegation (ADR-001)
-   * When set, core operations delegate to @sparkleideas/agentic-flow's optimized implementations
+   * Reference to agentic-flow Agent for delegation (ADR-001)
+   * When set, core operations delegate to agentic-flow's optimized implementations
    */
   private agenticFlowRef: AgenticFlowAgentReference | null = null;
 
   /**
-   * Indicates if delegation to @sparkleideas/agentic-flow is active
+   * Indicates if delegation to agentic-flow is active
    */
   private delegationEnabled: boolean = false;
 
@@ -341,18 +341,18 @@ export class AgenticFlowAgent extends EventEmitter implements IAgent {
   }
 
   /**
-   * Set @sparkleideas/agentic-flow Agent reference for delegation
+   * Set agentic-flow Agent reference for delegation
    *
-   * This implements ADR-001: Adopt @sparkleideas/agentic-flow as Core Foundation
+   * This implements ADR-001: Adopt agentic-flow as Core Foundation
    * When a reference is provided, task execution and other operations
-   * delegate to @sparkleideas/agentic-flow's optimized implementations.
+   * delegate to agentic-flow's optimized implementations.
    *
    * Benefits:
    * - Flash Attention for faster context processing (2.49x-7.47x speedup)
    * - SONA learning for real-time adaptation (<0.05ms)
    * - AgentDB for faster memory search (150x-12,500x improvement)
    *
-   * @param ref - The @sparkleideas/agentic-flow Agent reference
+   * @param ref - The agentic-flow Agent reference
    */
   setAgenticFlowReference(ref: AgenticFlowAgentReference): void {
     this.agenticFlowRef = ref;
@@ -360,20 +360,20 @@ export class AgenticFlowAgent extends EventEmitter implements IAgent {
 
     this.emit('delegation-enabled', {
       agentId: this.id,
-      target: '@sparkleideas/agentic-flow',
+      target: 'agentic-flow',
       enabled: this.delegationEnabled,
     });
   }
 
   /**
-   * Check if delegation to @sparkleideas/agentic-flow is enabled
+   * Check if delegation to agentic-flow is enabled
    */
   isDelegationEnabled(): boolean {
     return this.delegationEnabled && this.agenticFlowRef !== null;
   }
 
   /**
-   * Get the @sparkleideas/agentic-flow reference (if available)
+   * Get the agentic-flow reference (if available)
    */
   getAgenticFlowReference(): AgenticFlowAgentReference | null {
     return this.agenticFlowRef;
@@ -382,8 +382,8 @@ export class AgenticFlowAgent extends EventEmitter implements IAgent {
   /**
    * Initialize the agent
    *
-   * ADR-001: When @sparkleideas/agentic-flow is available, delegates initialization
-   * to @sparkleideas/agentic-flow's Agent.initialize() for optimized setup.
+   * ADR-001: When agentic-flow is available, delegates initialization
+   * to agentic-flow's Agent.initialize() for optimized setup.
    */
   async initialize(): Promise<void> {
     if (this.initialized) {
@@ -393,7 +393,7 @@ export class AgenticFlowAgent extends EventEmitter implements IAgent {
     this.emit('initializing', { agentId: this.id });
 
     try {
-      // ADR-001: Delegate to @sparkleideas/agentic-flow when available
+      // ADR-001: Delegate to agentic-flow when available
       if (this.isDelegationEnabled() && this.agenticFlowRef?.initialize) {
         await this.agenticFlowRef.initialize();
         this.emit('delegation-success', {
@@ -427,8 +427,8 @@ export class AgenticFlowAgent extends EventEmitter implements IAgent {
   /**
    * Shutdown the agent gracefully
    *
-   * ADR-001: When @sparkleideas/agentic-flow is available, delegates shutdown
-   * to @sparkleideas/agentic-flow's Agent.shutdown() for clean termination.
+   * ADR-001: When agentic-flow is available, delegates shutdown
+   * to agentic-flow's Agent.shutdown() for clean termination.
    */
   async shutdown(): Promise<void> {
     this.emit('shutting-down', { agentId: this.id });
@@ -443,7 +443,7 @@ export class AgenticFlowAgent extends EventEmitter implements IAgent {
         this.currentTask = null;
       }
 
-      // ADR-001: Delegate to @sparkleideas/agentic-flow when available
+      // ADR-001: Delegate to agentic-flow when available
       if (this.isDelegationEnabled() && this.agenticFlowRef?.shutdown) {
         await this.agenticFlowRef.shutdown();
         this.emit('delegation-success', {
@@ -473,8 +473,8 @@ export class AgenticFlowAgent extends EventEmitter implements IAgent {
   /**
    * Execute a task
    *
-   * ADR-001: When @sparkleideas/agentic-flow is available, delegates task execution
-   * to @sparkleideas/agentic-flow's Agent.execute() which leverages:
+   * ADR-001: When agentic-flow is available, delegates task execution
+   * to agentic-flow's Agent.execute() which leverages:
    * - Flash Attention for 2.49x-7.47x faster processing
    * - SONA learning for real-time adaptation
    * - AgentDB for 150x-12,500x faster memory retrieval
@@ -510,7 +510,7 @@ export class AgenticFlowAgent extends EventEmitter implements IAgent {
     try {
       let output: unknown;
 
-      // ADR-001: Delegate to @sparkleideas/agentic-flow when available for optimized execution
+      // ADR-001: Delegate to agentic-flow when available for optimized execution
       if (this.isDelegationEnabled() && this.agenticFlowRef?.execute) {
         output = await this.agenticFlowRef.execute(task);
 
@@ -520,7 +520,7 @@ export class AgenticFlowAgent extends EventEmitter implements IAgent {
           taskId: task.id,
         });
       } else {
-        // Local execution (fallback or when @sparkleideas/agentic-flow not available)
+        // Local execution (fallback or when agentic-flow not available)
         output = await this.localExecuteTask(task);
       }
 
@@ -580,7 +580,7 @@ export class AgenticFlowAgent extends EventEmitter implements IAgent {
   /**
    * Send a message to another agent
    *
-   * ADR-001: When @sparkleideas/agentic-flow is available, delegates to @sparkleideas/agentic-flow's
+   * ADR-001: When agentic-flow is available, delegates to agentic-flow's
    * message routing which uses optimized communication channels.
    *
    * @param to - Target agent ID
@@ -596,7 +596,7 @@ export class AgenticFlowAgent extends EventEmitter implements IAgent {
     });
 
     try {
-      // ADR-001: Delegate to @sparkleideas/agentic-flow when available
+      // ADR-001: Delegate to agentic-flow when available
       if (this.isDelegationEnabled() && this.agenticFlowRef?.sendMessage) {
         await this.agenticFlowRef.sendMessage(to, message);
 
@@ -659,7 +659,7 @@ export class AgenticFlowAgent extends EventEmitter implements IAgent {
   /**
    * Get agent health information
    *
-   * ADR-001: When @sparkleideas/agentic-flow is available, delegates to @sparkleideas/agentic-flow's
+   * ADR-001: When agentic-flow is available, delegates to agentic-flow's
    * health monitoring which includes advanced metrics.
    */
   getHealth(): AgentHealth {