@sparkleideas/integration 3.0.2 → 3.0.4

package/src/swarm-adapter.ts

@@ -1,12 +1,12 @@
 /**
- * SwarmAdapter - Bridge between V3 Swarm and @sparkleideas/agentic-flow@alpha Patterns
+ * SwarmAdapter - Bridge between V3 Swarm and agentic-flow@alpha Patterns
  *
  * Provides bidirectional conversion and delegation patterns between:
  * - Claude Flow v3 UnifiedSwarmCoordinator
- * - @sparkleideas/agentic-flow's AttentionCoordinator, SwarmTopology, and Expert routing
+ * - agentic-flow's AttentionCoordinator, SwarmTopology, and Expert routing
  *
- * This implements ADR-001: Adopt @sparkleideas/agentic-flow as Core Foundation
- * by aligning V3 swarm patterns with @sparkleideas/agentic-flow's coordination mechanisms.
+ * This implements ADR-001: Adopt agentic-flow as Core Foundation
+ * by aligning V3 swarm patterns with agentic-flow's coordination mechanisms.
  *
  * Key Alignments:
  * - Topology: mesh, hierarchical, ring, star (maps V3's centralized -> star)
@@ -22,17 +22,17 @@
 import { EventEmitter } from 'events';
 
 // ============================================================================
-// @sparkleideas/agentic-flow Pattern Types (Target Interface)
+// agentic-flow Pattern Types (Target Interface)
 // ============================================================================
 
 /**
- * @sparkleideas/agentic-flow SwarmTopology types
+ * agentic-flow SwarmTopology types
  * V3's 'centralized' maps to 'star', 'hybrid' is represented as 'mesh' with hierarchical overlay
  */
 export type AgenticFlowTopology = 'mesh' | 'hierarchical' | 'ring' | 'star';
 
 /**
- * @sparkleideas/agentic-flow Attention mechanism types
+ * agentic-flow Attention mechanism types
  */
 export type AgenticFlowAttentionMechanism =
   | 'flash'       // Flash Attention - fastest, 75% memory reduction
@@ -42,8 +42,8 @@ export type AgenticFlowAttentionMechanism =
   | 'multi-head'; // Standard multi-head attention
 
 /**
- * @sparkleideas/agentic-flow AgentOutput interface
- * This is the expected output format from agents in @sparkleideas/agentic-flow swarms
+ * agentic-flow AgentOutput interface
+ * This is the expected output format from agents in agentic-flow swarms
  */
 export interface AgenticFlowAgentOutput {
   /** Agent identifier */
@@ -61,7 +61,7 @@ export interface AgenticFlowAgentOutput {
 }
 
 /**
- * @sparkleideas/agentic-flow SpecializedAgent interface
+ * agentic-flow SpecializedAgent interface
  * Represents an expert agent with specific capabilities
  */
 export interface AgenticFlowSpecializedAgent {
@@ -82,7 +82,7 @@ export interface AgenticFlowSpecializedAgent {
 }
 
 /**
- * @sparkleideas/agentic-flow Expert routing result
+ * agentic-flow Expert routing result
  */
 export interface AgenticFlowExpertRoute {
   /** Selected expert IDs */
@@ -96,7 +96,7 @@ export interface AgenticFlowExpertRoute {
 }
 
 /**
- * @sparkleideas/agentic-flow Attention coordination result
+ * agentic-flow Attention coordination result
  */
 export interface AgenticFlowAttentionResult {
   /** Consensus output */
@@ -212,7 +212,7 @@ export interface SwarmAdapterConfig {
   moeTopK: number;
   /** GraphRoPE dimension */
   ropeDimension: number;
-  /** Enable delegation to @sparkleideas/agentic-flow when available */
+  /** Enable delegation to agentic-flow when available */
   enableDelegation: boolean;
   /** Fallback on delegation failure */
   fallbackOnError: boolean;
@@ -240,10 +240,10 @@ const DEFAULT_CONFIG: SwarmAdapterConfig = {
 // ============================================================================
 
 /**
- * SwarmAdapter - Bridges V3 Swarm with @sparkleideas/agentic-flow patterns
+ * SwarmAdapter - Bridges V3 Swarm with agentic-flow patterns
  *
  * Key Features:
- * - Topology conversion (V3 <-> @sparkleideas/agentic-flow)
+ * - Topology conversion (V3 <-> agentic-flow)
  * - Agent output format conversion
  * - Specialized agent wrapping
  * - MoE expert routing integration
@@ -259,7 +259,7 @@ const DEFAULT_CONFIG: SwarmAdapterConfig = {
  *   enableMoERouting: true,
  * });
  *
- * // Convert V3 agents to @sparkleideas/agentic-flow format
+ * // Convert V3 agents to agentic-flow format
  * const specializedAgents = adapter.toSpecializedAgents(v3Agents);
  *
  * // Route task to experts using MoE
@@ -274,12 +274,12 @@ export class SwarmAdapter extends EventEmitter {
   private initialized: boolean = false;
 
   /**
-   * Reference to @sparkleideas/agentic-flow core for delegation
+   * Reference to agentic-flow core for delegation
    */
   private agenticFlowCore: any = null;
 
   /**
-   * Reference to @sparkleideas/agentic-flow AttentionCoordinator
+   * Reference to agentic-flow AttentionCoordinator
    */
   private attentionCoordinator: any = null;
 
@@ -313,7 +313,7 @@ export class SwarmAdapter extends EventEmitter {
     this.emit('initializing');
 
     try {
-      // Attempt to connect to @sparkleideas/agentic-flow for delegation
+      // Attempt to connect to agentic-flow for delegation
       if (this.config.enableDelegation) {
         await this.connectToAgenticFlow();
       }
@@ -356,12 +356,12 @@ export class SwarmAdapter extends EventEmitter {
   // ==========================================================================
 
   /**
-   * Convert V3 topology type to @sparkleideas/agentic-flow topology
+   * Convert V3 topology type to agentic-flow topology
    *
    * Mapping:
    * - mesh -> mesh
    * - hierarchical -> hierarchical
-   * - centralized -> star (@sparkleideas/agentic-flow uses 'star' for central coordinator pattern)
+   * - centralized -> star (agentic-flow uses 'star' for central coordinator pattern)
    * - hybrid -> mesh (treated as mesh with additional hierarchical overlay)
    */
   convertTopology(v3Topology: V3TopologyType): AgenticFlowTopology {
@@ -376,7 +376,7 @@ export class SwarmAdapter extends EventEmitter {
   }
 
   /**
-   * Convert @sparkleideas/agentic-flow topology to V3 topology type
+   * Convert agentic-flow topology to V3 topology type
    */
   convertTopologyFromAgenticFlow(topology: AgenticFlowTopology): V3TopologyType {
     const mapping: Record<AgenticFlowTopology, V3TopologyType> = {
@@ -394,10 +394,10 @@ export class SwarmAdapter extends EventEmitter {
   // ==========================================================================
 
   /**
-   * Convert V3 Agent to @sparkleideas/agentic-flow AgentOutput format
+   * Convert V3 Agent to agentic-flow AgentOutput format
    *
    * Creates the embedding from agent capabilities and produces
-   * the standardized AgentOutput interface expected by @sparkleideas/agentic-flow.
+   * the standardized AgentOutput interface expected by agentic-flow.
    */
   toAgentOutput(
     agent: V3AgentState,
@@ -427,7 +427,7 @@ export class SwarmAdapter extends EventEmitter {
   }
 
   /**
-   * Convert V3 Agent to @sparkleideas/agentic-flow SpecializedAgent format
+   * Convert V3 Agent to agentic-flow SpecializedAgent format
    *
    * Creates an expert representation suitable for MoE routing
    */
@@ -459,7 +459,7 @@ export class SwarmAdapter extends EventEmitter {
   }
 
   /**
-   * Convert @sparkleideas/agentic-flow SpecializedAgent back to partial V3 format
+   * Convert agentic-flow SpecializedAgent back to partial V3 format
    * (for updates/sync)
    */
   fromSpecializedAgent(
@@ -503,7 +503,7 @@ export class SwarmAdapter extends EventEmitter {
   /**
    * Route a task to the best experts using MoE attention
    *
-   * Implements @sparkleideas/agentic-flow's expert routing pattern for task assignment.
+   * Implements agentic-flow's expert routing pattern for task assignment.
    * Uses cosine similarity with load balancing for optimal routing.
    */
   async routeToExperts(
@@ -515,7 +515,7 @@ export class SwarmAdapter extends EventEmitter {
     const startTime = performance.now();
     const k = topK ?? this.config.moeTopK;
 
-    // If delegation is available and enabled, use @sparkleideas/agentic-flow's MoE
+    // If delegation is available and enabled, use agentic-flow's MoE
     if (this.config.enableMoERouting && this.agenticFlowCore?.moe) {
       try {
         const result = await this.agenticFlowCore.moe.route({
@@ -589,7 +589,7 @@ export class SwarmAdapter extends EventEmitter {
   /**
    * Coordinate agent outputs using attention mechanisms
    *
-   * Implements @sparkleideas/agentic-flow's attention-based consensus pattern
+   * Implements agentic-flow's attention-based consensus pattern
    * for multi-agent coordination.
    */
   async coordinateWithAttention(
@@ -600,7 +600,7 @@ export class SwarmAdapter extends EventEmitter {
     const startTime = performance.now();
     const useMechanism = mechanism ?? this.config.defaultAttentionMechanism;
 
-    // If delegation is available, use @sparkleideas/agentic-flow's AttentionCoordinator
+    // If delegation is available, use agentic-flow's AttentionCoordinator
     if (
       this.config.enableAttentionCoordination &&
       this.attentionCoordinator
@@ -772,7 +772,7 @@ export class SwarmAdapter extends EventEmitter {
   // ==========================================================================
 
   /**
-   * Map V3 domain to @sparkleideas/agentic-flow specialization
+   * Map V3 domain to agentic-flow specialization
    */
   mapDomainToSpecialization(domain: V3AgentDomain): string {
     const mapping: Record<V3AgentDomain, string> = {
@@ -787,7 +787,7 @@ export class SwarmAdapter extends EventEmitter {
   }
 
   /**
-   * Map @sparkleideas/agentic-flow specialization to V3 domain
+   * Map agentic-flow specialization to V3 domain
    */
   mapSpecializationToDomain(specialization: string): V3AgentDomain {
     const lower = specialization.toLowerCase();
@@ -820,7 +820,7 @@ export class SwarmAdapter extends EventEmitter {
   // ==========================================================================
 
   /**
-   * Check if delegation to @sparkleideas/agentic-flow is available
+   * Check if delegation to agentic-flow is available
    */
   isDelegationAvailable(): boolean {
     return this.agenticFlowCore !== null;
@@ -848,7 +848,7 @@ export class SwarmAdapter extends EventEmitter {
   private async connectToAgenticFlow(): Promise<void> {
     try {
       // 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 &&
@@ -867,7 +867,7 @@ export class SwarmAdapter extends EventEmitter {
           hasMoE: !!this.agenticFlowCore.moe,
         });
 
-        this.logDebug('Connected to @sparkleideas/agentic-flow', {
+        this.logDebug('Connected to agentic-flow', {
           version: this.agenticFlowCore.version,
         });
       } else {
@@ -886,7 +886,7 @@ export class SwarmAdapter extends EventEmitter {
 
   private generateAgentEmbedding(agent: V3AgentState): number[] {
     // Generate hash-based embedding from agent properties
-    // For ML embeddings, use: import('@sparkleideas/agentic-flow').computeEmbedding
+    // For ML embeddings, use: import('agentic-flow').computeEmbedding
     const embedding = new Array(128).fill(0);
 
     // Encode agent type

package/src/token-optimizer.ts

@@ -1,5 +1,5 @@
 /**
- * Token Optimizer - Integrates @sparkleideas/agentic-flow Agent Booster capabilities
+ * Token Optimizer - Integrates agentic-flow Agent Booster capabilities
  *
  * Combines:
  * - Agent Booster (352x code edit speedup)
@@ -11,7 +11,7 @@
 
 import { EventEmitter } from 'events';
 
-// Types for @sparkleideas/agentic-flow integration
+// Types for agentic-flow integration
 interface TokenStats {
   saved: number;
   baseline: number;
@@ -42,7 +42,7 @@ async function safeImport<T>(modulePath: string): Promise<T | null> {
 }
 
 /**
- * Token Optimizer - Reduces token usage via @sparkleideas/agentic-flow integration
+ * Token Optimizer - Reduces token usage via agentic-flow integration
  */
 export class TokenOptimizer extends EventEmitter {
   private stats = {
@@ -61,20 +61,20 @@ export class TokenOptimizer extends EventEmitter {
 
   async initialize(): Promise<void> {
     try {
-      // Dynamic import of @sparkleideas/agentic-flow main module
-      const af = await safeImport<any>('@sparkleideas/agentic-flow');
+      // Dynamic import of agentic-flow main module
+      const af = await safeImport<any>('agentic-flow');
 
       if (af) {
         this.agenticFlowAvailable = true;
 
         // Load ReasoningBank (exported path)
-        const rb = await safeImport<any>('@sparkleideas/agentic-flow/reasoningbank');
+        const rb = await safeImport<any>('agentic-flow/reasoningbank');
         if (rb && rb.retrieveMemories) {
           this.reasoningBank = rb;
         }
 
         // Load Agent Booster (exported path)
-        const ab = await safeImport<any>('@sparkleideas/agentic-flow/agent-booster');
+        const ab = await safeImport<any>('agentic-flow/agent-booster');
         if (ab) {
           // Agent booster may export different API
           this.agentBooster = ab.agentBooster || ab.AgentBooster || ab;

package/src/types.ts

@@ -1,8 +1,8 @@
 /**
  * V3 Integration Module Types
  *
- * Type definitions for deep integration with @sparkleideas/agentic-flow@alpha.
- * Implements ADR-001: Adopt @sparkleideas/agentic-flow as Core Foundation
+ * Type definitions for deep integration with agentic-flow@alpha.
+ * Implements ADR-001: Adopt agentic-flow as Core Foundation
  *
  * @module v3/integration/types
  * @version 3.0.0-alpha.1
@@ -117,7 +117,7 @@ export interface SONALearningStats {
 // ===== Flash Attention Types =====
 
 /**
- * Attention mechanism types supported by @sparkleideas/agentic-flow.
+ * Attention mechanism types supported by agentic-flow.
  * Flash Attention provides 2.49x-7.47x speedup with 50-75% memory reduction.
  */
 export type AttentionMechanism =
@@ -260,7 +260,7 @@ export interface IntegrationConfig {
   /** Attention configuration */
   attention: Partial<AttentionConfiguration>;
   /** AgentDB configuration */
-  @sparkleideas/agentdb: Partial<AgentDBConfiguration>;
+  agentdb: Partial<AgentDBConfiguration>;
   /** Feature flags */
   features: FeatureFlags;
   /** Runtime preference (auto-detection order) */
@@ -486,7 +486,7 @@ export const DEFAULT_FEATURE_FLAGS: FeatureFlags = {
 export const DEFAULT_INTEGRATION_CONFIG: IntegrationConfig = {
   sona: DEFAULT_SONA_CONFIG,
   attention: DEFAULT_ATTENTION_CONFIG,
-  @sparkleideas/agentdb: DEFAULT_AGENTDB_CONFIG,
+  agentdb: DEFAULT_AGENTDB_CONFIG,
   features: DEFAULT_FEATURE_FLAGS,
   runtimePreference: ['napi', 'wasm', 'js'],
   lazyLoad: true,

package/src/worker-base.ts

@@ -2,7 +2,7 @@
  * WorkerBase - Abstract Base Worker Class
  *
  * Provides the foundation for all worker patterns in Claude Flow v3,
- * aligned with @sparkleideas/agentic-flow@alpha's worker architecture.
+ * aligned with agentic-flow@alpha's worker architecture.
  *
  * Key Features:
  * - Specialization embeddings for intelligent task routing
@@ -10,7 +10,7 @@
  * - Capability-based task matching
  * - Memory and coordination integration
  *
- * This implements ADR-001 by building on @sparkleideas/agentic-flow patterns
+ * This implements ADR-001 by building on agentic-flow patterns
  * while providing Claude Flow-specific extensions.
  *
  * @module v3/integration/worker-base
@@ -110,7 +110,7 @@ export interface WorkerProviderConfig {
 }
 
 /**
- * Agent output interface (compatible with @sparkleideas/agentic-flow)
+ * Agent output interface (compatible with agentic-flow)
  */
 export interface AgentOutput {
   /** Output content */

package/src/worker-pool.ts

@@ -11,7 +11,7 @@
  * - Health monitoring and auto-recovery
  * - Type-safe worker registry
  *
- * Compatible with @sparkleideas/agentic-flow's worker pool patterns.
+ * Compatible with agentic-flow's worker pool patterns.
  *
  * @module v3/integration/worker-pool
  * @version 3.0.0-alpha.1