AI agents

func (sa *Analyzer) AnalyzeQuery(query string) model.QueryIntent {
    queryLower := strings.ToLower(query)
    words := strings.Fields(queryLower)

    intent := model.QueryIntent{
        Confidence:     0.0,
        TargetServices: []string{},
        Urgency:        "medium",
        TimeFrame:      "recent",
        DataTypes:      []string{},
    }

    // Score intent by summing word weights
    intentScores := make(map[string]float64)
    for intentType, signals := range sa.IntentSignals {
        score := 0.0
        for _, word := range words {
            if weight, exists := signals[word]; exists {
                score += weight
            }
        }
        intentScores[intentType] = score
    }

    // Select highest-scoring intent
    maxScore := 0.0
    for intentType, score := range intentScores {
        if score > maxScore {
            maxScore = score
            intent.Primary = intentType
        }
    }

    // Calculate confidence based on query length
    if len(words) > 0 {
        intent.Confidence = math.Min(maxScore/float64(len(words)), 1.0)
    }

    // Identify target services
    for service, keywords := range sa.ServiceMapping {
        for _, keyword := range keywords {
            if strings.Contains(queryLower, keyword) {
                intent.TargetServices = append(intent.TargetServices, service)
                break
            }
        }
    }

func (t *Tree) Traverse(query string, ctx *model.AgentContext) []*Node {
    var applicable []*Node
    t.traverseNode(t.Root, query, ctx, &applicable)
    return applicable
}

func (t *Tree) traverseNode(node *Node, query string, ctx *model.AgentContext, applicable *[]*Node) {
    if t.evaluateCondition(node.Condition, query) {
        *applicable = append(*applicable, node)
        t.CurrentPath = append(t.CurrentPath, node.ID)
        t.Decisions = append(t.Decisions, *node)
        for _, child := range node.Children {
            t.traverseNode(child, query, ctx, applicable)
        }
    }
}

func (c *Coordinator) SpawnAgents(ctx context.Context, applicable []*dt.Node) {
    agentConfigs := make(map[string]AgentConfig)

    for _, node := range applicable {
        for _, name := range node.AgentTypes {
            agt, ok := c.lookupAgentType(name)
            if !ok {
                continue
            }
            if existing, exists := agentConfigs[name]; !exists || node.Priority > existing.Priority {
                agentConfigs[name] = AgentConfig{
                    Priority:   node.Priority,
                    Parameters: node.Parameters,
                    AgentType:  agt,
                }
            }
        }
    }

    if len(agentConfigs) == 0 {
        return
    }

    // Plan execution order based on dependencies
    planned := c.scheduler.Plan(agentConfigs)
    verbose := verboseAgents()

    // Execute agents in dependency order
    for _, group := range planned {
        if verbose {
            fmt.Printf("📊 Executing order group %d with %d agents\n", group.Order, len(group.Agents))
        }
        var wg sync.WaitGroup
        for _, cfg := range group.Agents {
            if !c.scheduler.Ready(cfg.AgentType, c.dataBus) {
                if verbose {
                    fmt.Printf("⏸️  Agent %s waiting for dependencies\n", cfg.AgentType.Name)
                }
                continue
            }
            agent := c.newParallelAgent(cfg)
            c.registry.Register(agent)
            wg.Add(1)
            go c.runPlannedAgent(ctx, &wg, agent)
        }
        wg.Wait()
        if verbose {
            fmt.Printf("✅ Order group %d completed\n", group.Order)
        }
    }
}

a.addThought(agentCtx, fmt.Sprintf("Starting investigation of query: '%s'", query), "analyze", "Query received, beginning analysis")
a.addThought(agentCtx, fmt.Sprintf("Semantic analysis: Intent=%s, Confidence=%.2f, Urgency=%s",
    queryIntent.Primary, queryIntent.Confidence, queryIntent.Urgency), "analyze", "Performed semantic analysis")

// ...

a.addThought(agentCtx, fmt.Sprintf("Decision tree identified %d applicable strategies", len(applicableNodes)), "analyze", "Determined parallel execution strategy")

// ...

stats := coord.Stats()
a.addThought(agentCtx, fmt.Sprintf("Completed parallel execution with %d agents", stats.Total), "success", "Data gathering completed")

if verbose {
    fmt.Printf("🎉 Parallel execution completed: %d successful, %d failed\n",
        stats.Completed, stats.Failed)
}