@llm-dev-ops/agentics-cli 1.4.26 → 1.4.27

package/dist/commands/agents.js

@@ -12,6 +12,9 @@
 import { loadEndpointConfig } from '../config/endpoints.js';
 import { createAdapter } from '../adapters/base-adapter.js';
 import { getAnthropicApiKey } from '../utils/credentials.js';
+import { executeSimulateCommand } from './simulate.js';
+import { detectEnterpriseSimulation, classifyIntent as semanticClassifyIntent, classifyMultiIntent as semanticClassifyMultiIntent, } from './intent-classifier.js';
+import { isRepoAgentMode, hasRepoAgent, executeRepoAgent, } from '../agents/repo-agent-runner.js';
 export const AGENT_DOMAINS = {
     'test-bench': {
         serviceName: 'test-bench-agents',
@@ -203,14 +206,49 @@ export async function executeAgentsInvokeCommand(domain, agent, payload, options
     if (!domainConfig.agents.includes(agent)) {
         throw new Error(`Unknown agent '${agent}' in domain '${domain}'. Valid agents: ${domainConfig.agents.join(', ')}`);
     }
-    const config = loadEndpointConfig(domainConfig.serviceName);
     const correlationId = options.trace_id ?? crypto.randomUUID();
+    // Normalize payload: if caller sends generic { text: "..." } but the domain
+    // expects a different schema, transform it via buildDomainPayload.
+    let normalizedPayload = payload;
+    if (payload && typeof payload === 'object' && 'text' in payload) {
+        const payloadObj = payload;
+        const text = payloadObj['text'];
+        if (text && typeof text === 'string') {
+            // Check if domain needs specific payload format
+            const needsTransform = ['simulator', 'platform', 'copilot', 'governance-dashboard', 'costops', 'policy-engine'].includes(domain);
+            if (needsTransform) {
+                normalizedPayload = buildDomainPayload(domain, agent, text, correlationId);
+            }
+        }
+    }
+    // Repo-local mode: download the Cloud Function's source, inject claude shim,
+    // and run the handler in-process. Uses Claude Code (Claude Max) for AI — no API key.
+    if (isRepoAgentMode() && hasRepoAgent(domain)) {
+        if (options.verbose) {
+            console.error(`[repo-local] Executing ${domain}/${agent} using repo code + Claude Code`);
+        }
+        return executeRepoAgent(domain, agent, normalizedPayload, correlationId);
+    }
+    const config = loadEndpointConfig(domainConfig.serviceName);
     const adapter = createAdapter(domainConfig.serviceName, config, correlationId);
+    // Attach Anthropic API key for agents that need LLM inference (e.g. copilot)
+    const invokeHeaders = {};
+    if (domainConfig.serviceName === 'copilot-agents') {
+        const anthropicKey = await getAnthropicApiKey();
+        if (anthropicKey) {
+            invokeHeaders['X-Anthropic-Api-Key'] = anthropicKey;
+        }
+    }
+    // governance-dashboard requires execution context in HTTP headers, not body
+    if (domain === 'governance-dashboard') {
+        invokeHeaders['x-execution-id'] = correlationId;
+        invokeHeaders['x-parent-span-id'] = correlationId;
+    }
     const response = await adapter.invoke({
         endpoint: `/v1/${domain}/${agent}`,
         method: 'POST',
-        headers: {},
-        body: payload,
+        headers: invokeHeaders,
+        body: normalizedPayload,
     });
     return {
         domain,
@@ -500,6 +538,9 @@ const MULTI_AGENT_COMBOS = [
         agents: [{ domain: 'connector-hub', agent: 'database-query' }, { domain: 'connector-hub', agent: 'erp-surface' }, { domain: 'connector-hub', agent: 'auth-identity' }] },
     { id: 'smart-routing', keywords: ['smart routing', 'route inference optimal', 'intelligent routing'],
         agents: [{ domain: 'inference-gateway', agent: 'route' }, { domain: 'auto-optimizer', agent: 'model-select' }, { domain: 'costops', agent: 'tradeoff' }] },
+    // === Simulation (MUST match before governance/compliance keywords) ===
+    { id: 'scenario-simulation', keywords: ['simulate scenario', 'test scenario', 'deployment scenario', 'simulate a ', 'simulate an ', 'simulate the ', 'run simulation', 'run a simulation', 'simulation of'],
+        agents: [{ domain: 'simulator', agent: 'scenario' }, { domain: 'simulator', agent: 'what-if' }, { domain: 'platform', agent: 'risk-score' }] },
     // === Executive & Governance ===
     { id: 'executive-brief', keywords: ['executive summary', 'board report', 'platform summary', 'executive overview'],
         agents: [{ domain: 'platform', agent: 'executive-summary' }, { domain: 'costops', agent: 'attribution' }, { domain: 'observatory', agent: 'slo' }, { domain: 'research-lab', agent: 'metrics' }] },
@@ -507,7 +548,7 @@ const MULTI_AGENT_COMBOS = [
         agents: [{ domain: 'platform', agent: 'decision' }, { domain: 'platform', agent: 'decision-memo' }, { domain: 'platform', agent: 'risk-score' }, { domain: 'costops', agent: 'roi' }] },
     { id: 'risk-assessment', keywords: ['risk assess', 'how risky', 'risk evaluat', 'risk analys'],
         agents: [{ domain: 'platform', agent: 'risk-score' }, { domain: 'governance-dashboard', agent: 'impact' }, { domain: 'simulator', agent: 'scenario' }] },
-    { id: 'compliance-review', keywords: ['compliance check', 'are we compliant', 'gdpr complian', 'hipaa complian', 'governance review', 'gdpr', 'hipaa', 'compliance', 'are we compliant', 'regulatory'],
+    { id: 'compliance-review', keywords: ['compliance check', 'are we compliant', 'gdpr complian', 'hipaa complian', 'governance review', 'gdpr audit', 'hipaa audit', 'compliance audit', 'compliance review', 'regulatory compliance review'],
         agents: [{ domain: 'governance-dashboard', agent: 'audit' }, { domain: 'governance-dashboard', agent: 'oversight' }, { domain: 'policy-engine', agent: 'enforce' }, { domain: 'data-vault', agent: 'access-control' }] },
     { id: 'impact-analysis', keywords: ['impact analys', 'blast radius', 'change impact'],
         agents: [{ domain: 'governance-dashboard', agent: 'impact' }, { domain: 'platform', agent: 'risk-score' }, { domain: 'simulator', agent: 'scenario' }, { domain: 'sentinel', agent: 'correlation' }] },
@@ -520,65 +561,184 @@ const MULTI_AGENT_COMBOS = [
     // === Planning ===
     { id: 'task-planning', keywords: ['help me plan', 'break down this', 'plan this task', 'decompose this'],
         agents: [{ domain: 'copilot', agent: 'planner' }, { domain: 'copilot', agent: 'decomposer' }, { domain: 'copilot', agent: 'clarifier' }] },
-    { id: 'scenario-simulation', keywords: ['simulate scenario', 'test scenario', 'deployment scenario'],
-        agents: [{ domain: 'simulator', agent: 'scenario' }, { domain: 'simulator', agent: 'what-if' }, { domain: 'platform', agent: 'risk-score' }] },
     { id: 'version-health', keywords: ['version compat', 'is this deprecated', 'api still supported'],
         agents: [{ domain: 'forge', agent: 'version-compat' }, { domain: 'marketplace', agent: 'deprecation' }, { domain: 'registry', agent: 'index' }] },
     { id: 'agent-onboarding', keywords: ['onboard agent', 'register new agent', 'new agent setup'],
         agents: [{ domain: 'registry', agent: 'bootstrap' }, { domain: 'registry', agent: 'index' }, { domain: 'config-manager', agent: 'validate' }] },
 ];
+// ============================================================================
+// Payload Adapter: map generic { text } to domain-specific required fields
+// ============================================================================
 /**
- * Classify a query against multi-agent combos.
- * Returns an array of intents if a combo matches, or null.
+ * Build a dispatch payload adapted to each agent domain's required schema.
+ * Downstream agents expect different field names (e.g. copilot wants "objective",
+ * simulator wants "scenario_id" + "parameters"). This function maps the user's
+ * natural-language query into the correct shape.
  */
-function classifyMultiAgent(query) {
-    const q = query.toLowerCase();
-    for (const combo of MULTI_AGENT_COMBOS) {
-        for (const kw of combo.keywords) {
-            if (q.includes(kw)) {
-                // Verify all agents exist in registry
-                const validAgents = combo.agents.filter(({ domain, agent }) => {
-                    const dc = AGENT_DOMAINS[domain];
-                    return dc && dc.agents.includes(agent);
-                });
-                if (validAgents.length >= 2) {
-                    return validAgents.map(({ domain, agent }) => ({
-                        domain,
-                        agent,
-                        confidence: 0.75,
-                        suggested_payload: {},
-                        reasoning: `Multi-agent combo "${combo.id}" keyword: "${kw}"`,
-                    }));
-                }
+function buildDomainPayload(domain, agent, query, correlationId) {
+    // Some agents have strict schema validation and reject unknown properties.
+    // Only include execution_ref for agents that accept it.
+    const base = { execution_ref: correlationId };
+    switch (domain) {
+        case 'copilot':
+            return { ...base, objective: query };
+        case 'simulator':
+            // Simulator agents use strict validation — no extra properties allowed.
+            if (agent === 'what-if') {
+                return { input: query, domain: 'enterprise' };
             }
+            // scenario agent
+            return {
+                scenario_id: `sim-${correlationId.slice(0, 8)}`,
+                parameters: { description: query },
+            };
+        case 'platform':
+            // Platform agents use strict Zod validation — no extra properties.
+            return { objective: query };
+        case 'governance-dashboard':
+            // governance-dashboard requires execution context in HEADERS (x-execution-id, x-parent-span-id).
+            // Body carries the query. Headers are injected separately in executeAgentsInvokeCommand.
+            return { text: query, scope: 'full' };
+        case 'policy-engine':
+            // policy-engine expects { text, scope, agent } — include execution_ref for tracing
+            return { execution_ref: correlationId, text: query, scope: 'full', agent };
+        case 'costops': {
+            // CostOps agents require structured cost data — build synthetic payloads for NL queries.
+            const now = new Date().toISOString();
+            if (agent === 'attribution') {
+                return {
+                    requestId: correlationId,
+                    timestamp: now,
+                    usage: {
+                        provider: 'anthropic',
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        model: 'claude-sonnet-4-20250514',
+                    },
+                    query,
+                };
+            }
+            if (agent === 'forecast') {
+                // Requires at least 7 data points with timestamp + total_cost
+                const historicalData = Array.from({ length: 7 }, (_, i) => ({
+                    timestamp: new Date(Date.now() - (7 - i) * 24 * 60 * 60 * 1000).toISOString(),
+                    total_cost: 0,
+                    tokens: 0,
+                    provider: 'anthropic',
+                }));
+                return {
+                    historical_data: historicalData,
+                    forecast_horizon_days: 30,
+                    query,
+                };
+            }
+            if (agent === 'roi') {
+                const periodStart = new Date(Date.now() - 365 * 24 * 60 * 60 * 1000).toISOString();
+                return {
+                    analysis_scope: 'organization',
+                    period_start: periodStart,
+                    period_end: now,
+                    request_id: correlationId,
+                    cost_records: [{
+                            id: correlationId,
+                            timestamp: now,
+                            provider: 'Anthropic',
+                            model: 'claude-sonnet-4-20250514',
+                            prompt_tokens: 0,
+                            completion_tokens: 0,
+                            total_tokens: 0,
+                            cost_amount: '0.00',
+                            currency: 'USD',
+                        }],
+                    outcome_metrics: [{
+                            id: crypto.randomUUID(),
+                            timestamp: now,
+                            metric_type: 'task_completion',
+                            metric_name: 'tasks_completed',
+                            value: 0,
+                            unit: 'count',
+                        }],
+                    query,
+                };
+            }
+            if (agent === 'budget') {
+                return {
+                    request_id: correlationId,
+                    budget: { limit: 250000, currency: 'USD', period: 'annual' },
+                    spend_data: { current: 0, projected: 0 },
+                    timestamp: now,
+                    query,
+                };
+            }
+            if (agent === 'tradeoff') {
+                return {
+                    records: [{ model: 'claude-sonnet-4-20250514', cost: 0, quality_score: 0.85, latency_ms: 1200 }],
+                    query,
+                };
+            }
+            return { ...base, text: query };
         }
+        case 'data-vault':
+            if (agent === 'access-control') {
+                return {
+                    request_id: correlationId,
+                    subject: { type: 'user', id: 'cli-user' },
+                    resource: { type: 'query', id: correlationId },
+                    permission: 'read',
+                    context: { source: 'cli', query },
+                };
+            }
+            return { ...base, text: query };
+        default:
+            // Most agents accept { text } + extra fields
+            return { ...base, text: query };
     }
-    return null;
 }
 /**
- * Classify a query using keyword matching against the static rule table.
- * Returns the best match or null if no keywords match.
+ * Classify a query against multi-agent combos.
+ * Returns an array of intents if a combo matches, or null.
+ */
+function classifyMultiAgent(query) {
+    // Use semantic intent classifier instead of brittle .includes() matching
+    const result = semanticClassifyMultiIntent(query, MULTI_AGENT_COMBOS);
+    if (!result)
+        return null;
+    // Verify all agents exist in registry
+    const validAgents = result.agents.filter(({ domain, agent }) => {
+        const dc = AGENT_DOMAINS[domain];
+        return dc && dc.agents.includes(agent);
+    });
+    if (validAgents.length < 2)
+        return null;
+    return validAgents.map(({ domain, agent }) => ({
+        domain,
+        agent,
+        confidence: result.confidence,
+        suggested_payload: {},
+        reasoning: result.reasoning,
+    }));
+}
+/**
+ * Classify a query using semantic intent scoring against the static rule table.
+ * Uses multi-signal scoring (token overlap, stem matching, concept clusters)
+ * instead of brittle .includes() substring matching.
  */
 function classifyByKeywords(query) {
-    const q = query.toLowerCase();
-    for (const rule of KEYWORD_RULES) {
-        for (const kw of rule.keywords) {
-            if (q.includes(kw)) {
-                // Verify domain/agent exist in registry
-                const domainConfig = AGENT_DOMAINS[rule.domain];
-                if (domainConfig && domainConfig.agents.includes(rule.agent)) {
-                    return {
-                        domain: rule.domain,
-                        agent: rule.agent,
-                        confidence: 0.70, // keyword match — decent but not LLM-grade
-                        suggested_payload: {},
-                        reasoning: `Keyword match: "${kw}"`,
-                    };
-                }
-            }
-        }
+    const result = semanticClassifyIntent(query, KEYWORD_RULES);
+    if (!result)
+        return null;
+    // Verify domain/agent exist in registry
+    const domainConfig = AGENT_DOMAINS[result.domain];
+    if (!domainConfig || !domainConfig.agents.includes(result.agent)) {
+        return null;
     }
-    return null;
+    return {
+        domain: result.domain,
+        agent: result.agent,
+        confidence: result.confidence,
+        suggested_payload: {},
+        reasoning: result.reasoning,
+    };
 }
 // ============================================================================
 // Natural Language Routing (LLM with keyword fallback)
@@ -586,6 +746,109 @@ function classifyByKeywords(query) {
 export async function executeNaturalLanguageRoute(query, options) {
     const start = Date.now();
     const correlationId = options.trace_id ?? crypto.randomUUID();
+    // Priority 0: Enterprise simulation → ruvector pipeline + platform analysis agents
+    // Enterprise simulations go through agentics-simulation-engine → ruvector-service.
+    // Platform agents (risk-score, executive-summary, decision-memo) run in parallel
+    // to provide analysis on top of the simulation.
+    //
+    // Uses semantic intent classifier (not brittle keyword matching) to detect
+    // enterprise simulation intent from natural language queries.
+    {
+        const simDetection = detectEnterpriseSimulation(query);
+        if (simDetection.detected) {
+            console.error(`Enterprise simulation detected — ${simDetection.reasoning} (${(simDetection.confidence * 100).toFixed(0)}% confidence)`);
+            // Dispatch enterprise simulation AND platform analysis agents in parallel
+            const platformAgents = [
+                { domain: 'platform', agent: 'risk-score' },
+                { domain: 'platform', agent: 'executive-summary' },
+                { domain: 'platform', agent: 'decision-memo' },
+            ];
+            const simPromise = executeSimulateCommand({ planRef: { type: 'natural-language', description: query } }, { ...options, trace_id: correlationId }).then(result => ({ kind: 'simulation', status: 200, response: result }))
+                .catch(err => ({ kind: 'simulation', status: 502, response: { error: err instanceof Error ? err.message : String(err) } }));
+            const platformPromises = platformAgents.map(async ({ domain, agent }) => {
+                try {
+                    const domainConfig = AGENT_DOMAINS[domain];
+                    if (!domainConfig)
+                        return { kind: 'agent', domain, agent, status: 404, response: { error: `Unknown domain: ${domain}` } };
+                    const agentConfig = loadEndpointConfig(domainConfig.serviceName);
+                    const agentAdapter = createAdapter(domainConfig.serviceName, agentConfig, correlationId);
+                    const agentPayload = buildDomainPayload(domain, agent, query, correlationId);
+                    // Inject execution context headers for domains that require them
+                    const agentHeaders = {};
+                    if (domain === 'governance-dashboard') {
+                        agentHeaders['x-execution-id'] = correlationId;
+                        agentHeaders['x-parent-span-id'] = correlationId;
+                    }
+                    const resp = await agentAdapter.invoke({
+                        endpoint: `/v1/${domain}/${agent}`,
+                        method: 'POST',
+                        headers: agentHeaders,
+                        body: agentPayload,
+                    });
+                    return { kind: 'agent', domain, agent, status: resp.status, response: resp.body };
+                }
+                catch (err) {
+                    return { kind: 'agent', domain, agent, status: 502, response: { error: err instanceof Error ? err.message : String(err) } };
+                }
+            });
+            const allResults = await Promise.allSettled([simPromise, ...platformPromises]);
+            const elapsed = Date.now() - start;
+            // Build multi-result response matching MultiAgentRouteResult shape
+            const intents = [];
+            const invocations = [];
+            for (const settled of allResults) {
+                if (settled.status === 'fulfilled') {
+                    const val = settled.value;
+                    const domain = val.kind === 'simulation' ? 'simulator' : val.domain;
+                    const agent = val.kind === 'simulation' ? 'enterprise' : val.agent;
+                    const intent = {
+                        domain,
+                        agent,
+                        confidence: 1.0,
+                        suggested_payload: {},
+                        reasoning: val.kind === 'simulation' ? 'Enterprise simulation via ruvector pipeline' : `Platform analysis: ${agent}`,
+                    };
+                    intents.push(intent);
+                    if (val.status >= 200 && val.status < 300) {
+                        invocations.push({ intent, result: { domain, agent, status: val.status, response: val.response, timing: elapsed } });
+                    }
+                    else {
+                        const errMsg = val.response && typeof val.response === 'object' && 'error' in val.response
+                            ? String(val.response.error)
+                            : `HTTP ${val.status}`;
+                        invocations.push({ intent, result: { error: errMsg } });
+                    }
+                }
+            }
+            // Non-fatal: generate simulation artifacts to ~/.agentics/runs/<id>/
+            try {
+                const { generateSimulationArtifacts } = await import('../synthesis/simulation-artifact-generator.js');
+                const simResult = allResults[0]?.status === 'fulfilled' ? allResults[0].value : undefined;
+                const platformResults = allResults.slice(1)
+                    .filter((r) => r.status === 'fulfilled')
+                    .map(r => r.value);
+                const artifacts = await generateSimulationArtifacts({
+                    executionId: correlationId,
+                    query,
+                    simulationResult: simResult?.response,
+                    platformAnalysis: platformResults.map(p => ({ domain: p.domain, agent: p.agent, status: p.status, response: p.response })),
+                    correlationId,
+                    timing: elapsed,
+                });
+                console.error(`Simulation artifacts: ${artifacts.runDir}`);
+            }
+            catch { /* non-fatal — artifact generation should never block the response */ }
+            return {
+                kind: 'multi',
+                result: {
+                    query,
+                    intents,
+                    invocations,
+                    timing: elapsed,
+                },
+            };
+        }
+    }
     // Priority 1: Try multi-agent combo keywords (complex queries → 2-5 agents in parallel)
     {
         const multiIntents = classifyMultiAgent(query);
@@ -595,8 +858,7 @@ export async function executeNaturalLanguageRoute(query, options) {
             console.error(`Multi-agent routing: ${agentLabels}`);
             const dispatchPromises = multiIntents.map(async (intent) => {
                 const payload = {
-                    execution_ref: correlationId,
-                    text: query,
+                    ...buildDomainPayload(intent.domain, intent.agent, query, correlationId),
                     ...intent.suggested_payload,
                 };
                 try {
@@ -651,10 +913,9 @@ export async function executeNaturalLanguageRoute(query, options) {
             `    agentics agents invoke <domain> <agent> '<json-payload>'\n` +
             `    agentics agents list   # show available domains and agents`);
     }
-    // Build dispatch payload
+    // Build dispatch payload adapted to the target domain's schema
     const dispatchPayload = {
-        execution_ref: correlationId,
-        text: query,
+        ...buildDomainPayload(singleIntent.domain, singleIntent.agent, query, correlationId),
         ...singleIntent.suggested_payload,
     };
     // Dispatch to the target agent