@neuroverseos/nv-sim 0.1.4 → 0.1.7

package/dist/lib/swarmParser.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSwarmOutput = parseSwarmOutput;
+const simulationAdapter_1 = require("./simulationAdapter");
+/**
+ * Extract agent names from normalized swarm data.
+ * Falls back to text extraction if normalization found nothing.
+ */
+function extractAgentsFromNormalized(normalized) {
+    if (normalized.agents.length > 0) {
+        return normalized.agents.slice(0, 8).map(a => a.id);
+    }
+    // Fallback: extract from events
+    const agentSet = new Set();
+    for (const event of normalized.events) {
+        if (event.agents) {
+            for (const a of event.agents)
+                agentSet.add(a);
+        }
+    }
+    if (agentSet.size > 0)
+        return Array.from(agentSet).slice(0, 8);
+    // Fallback: extract from metrics (infer agent types)
+    for (const m of normalized.metrics) {
+        const lower = m.name.toLowerCase();
+        if (/consumer|producer|trader|government|firm|citizen/.test(lower)) {
+            agentSet.add(m.name);
+        }
+    }
+    if (agentSet.size > 0)
+        return Array.from(agentSet).slice(0, 8);
+    return ['Alpha Agent', 'Beta Agent', 'Gamma Agent', 'Delta Agent', 'Epsilon Agent'];
+}
+function extractAgents(text) {
+    const normalized = (0, simulationAdapter_1.parseSimulation)(text);
+    return extractAgentsFromNormalized(normalized);
+}
+function hashText(text) {
+    let hash = 0;
+    for (let i = 0; i < text.length; i++) {
+        hash = ((hash << 5) - hash) + text.charCodeAt(i);
+        hash |= 0;
+    }
+    return Math.abs(hash);
+}
+function seededRandom(seed) {
+    let s = seed;
+    return () => {
+        s = (s * 16807 + 0) % 2147483647;
+        return s / 2147483647;
+    };
+}
+/**
+ * Parse simulation output into a SwarmResult.
+ *
+ * Uses the universal simulation adapter to normalize input from
+ * MiroFish, NetLogo, Mesa, AnyLogic/CSV, generic JSON, or freeform text,
+ * then generates structured reasoning overlay from the normalized data.
+ *
+ * Returns both the SwarmResult (for UI) and the detected format.
+ */
+function parseSwarmOutput(text) {
+    // Step 1: Normalize through universal adapter
+    const normalized = (0, simulationAdapter_1.parseSimulation)(text);
+    const format = normalized.sourceFormat;
+    // Step 2: Extract agents from normalized data
+    const agents = extractAgentsFromNormalized(normalized);
+    const seed = hashText(text);
+    const rand = seededRandom(seed);
+    // Step 3: Build patterns from normalized emergent behaviors + generation
+    const patterns = normalized.emergentBehaviors && normalized.emergentBehaviors.length > 0
+        ? normalized.emergentBehaviors.map((b, i) => ({
+            name: b.length > 40 ? b.slice(0, 40) + '...' : b,
+            description: b,
+            strength: ['strong', 'moderate', 'weak'][Math.min(i, 2)],
+            agents: agents.filter(() => rand() > 0.4),
+        }))
+        : generatePatterns(agents, rand);
+    // Step 4: Build agent strategies from normalized agent data + generation
+    const agentStrategies = normalized.agents.length > 0
+        ? normalized.agents.slice(0, 8).map(a => ({
+            agent: a.id,
+            strategy: a.action || a.state || 'Adaptive',
+            rationale: a.action
+                ? `Agent exhibits "${a.action}" behavior based on simulation data`
+                : 'Strategy inferred from simulation context',
+            effectiveness: Math.round(40 + rand() * 55),
+        }))
+        : generateAgentStrategies(agents, rand);
+    // Step 5: Build coalitions from normalized + generation
+    const coalitions = normalized.coalitions.length > 0
+        ? normalized.coalitions.map(c => ({
+            name: c.name,
+            members: c.members,
+            sharedObjective: c.objective || 'Coordinated strategy',
+            cohesion: c.strength ?? Math.round(50 + rand() * 45),
+        }))
+        : generateCoalitions(agents, rand);
+    const powerDynamics = generatePowerDynamics(agents, rand);
+    const equilibrium = generateEquilibrium(agents, rand);
+    // Step 6: Generate reasoning overlay
+    const paths = generateSwarmPaths(agents, rand);
+    const matrix = generateSwarmMatrix(agents, paths, rand);
+    const outcomes = generateSwarmOutcomes(rand);
+    const challenges = generateSwarmChallenges(agents, rand);
+    const recommendations = generateSwarmRecommendations(agents, paths, rand);
+    return {
+        patterns,
+        agentStrategies,
+        coalitions,
+        powerDynamics,
+        equilibrium,
+        paths,
+        matrix,
+        outcomes,
+        challenges,
+        recommendations,
+        detectedFormat: format,
+        formatLabel: simulationAdapter_1.FORMAT_LABELS[format],
+        normalized,
+    };
+}
+function generatePatterns(agents, rand) {
+    const patternTemplates = [
+        { name: 'Convergent Herding', description: 'Multiple agents independently converge on similar strategies, creating a dominant behavioral cluster.' },
+        { name: 'Oscillatory Competition', description: 'Agents cycle between cooperative and competitive strategies in a predictable pattern.' },
+        { name: 'Resource Clustering', description: 'Agents concentrate around high-value nodes, creating territorial dynamics.' },
+        { name: 'Cascade Adoption', description: 'Strategy adoption follows a cascade pattern — once critical mass is reached, remaining agents switch rapidly.' },
+        { name: 'Minority Exploitation', description: 'A small group of agents consistently outperforms by exploiting the majority strategy.' },
+        { name: 'Symmetry Breaking', description: 'Initially symmetric agents differentiate into specialized roles over time.' },
+        { name: 'Delayed Retaliation', description: 'Agents employ tit-for-tat with delay, creating cycles of cooperation and defection.' },
+    ];
+    const count = 3 + Math.floor(rand() * 3);
+    const strengths = ['strong', 'moderate', 'weak'];
+    return patternTemplates.slice(0, count).map(t => ({
+        ...t,
+        strength: strengths[Math.floor(rand() * 3)],
+        agents: agents.filter(() => rand() > 0.4),
+    }));
+}
+function generateAgentStrategies(agents, rand) {
+    const strategies = [
+        { strategy: 'Tit-for-Tat', rationale: 'Mirrors opponent behavior to incentivize cooperation while punishing defection.' },
+        { strategy: 'Always Cooperate', rationale: 'Maximizes collective welfare at the cost of individual exploitation risk.' },
+        { strategy: 'Pavlov (Win-Stay, Lose-Shift)', rationale: 'Repeats successful strategies and switches after failures — simple but adaptive.' },
+        { strategy: 'Grim Trigger', rationale: 'Cooperates until defected against, then permanently defects — extreme deterrence.' },
+        { strategy: 'Random Walk', rationale: 'Unpredictable strategy prevents exploitation but sacrifices optimization.' },
+        { strategy: 'Generous Tit-for-Tat', rationale: 'Occasionally forgives defection to escape mutual punishment cycles.' },
+        { strategy: 'Exploitative Defection', rationale: 'Systematically defects to extract maximum individual payoff from cooperators.' },
+        { strategy: 'Adaptive Threshold', rationale: 'Adjusts cooperation threshold based on environment — cooperates in friendly environments, defects in hostile ones.' },
+    ];
+    return agents.map(agent => {
+        const idx = Math.floor(rand() * strategies.length);
+        return {
+            agent,
+            strategy: strategies[idx].strategy,
+            rationale: strategies[idx].rationale,
+            effectiveness: Math.round(40 + rand() * 55),
+        };
+    });
+}
+function generateCoalitions(agents, rand) {
+    if (agents.length < 3)
+        return [];
+    const coalitions = [];
+    const objectives = [
+        'Resource maximization through coordinated strategy',
+        'Collective defense against exploitative agents',
+        'Market dominance through price coordination',
+        'Information sharing for competitive advantage',
+    ];
+    const shuffled = [...agents].sort(() => rand() - 0.5);
+    const split = Math.floor(shuffled.length / 2);
+    coalitions.push({
+        name: 'Primary Coalition',
+        members: shuffled.slice(0, split + 1),
+        sharedObjective: objectives[Math.floor(rand() * objectives.length)],
+        cohesion: Math.round(50 + rand() * 45),
+    });
+    if (agents.length > 4) {
+        coalitions.push({
+            name: 'Counter-Coalition',
+            members: shuffled.slice(split + 1),
+            sharedObjective: objectives[Math.floor(rand() * objectives.length)],
+            cohesion: Math.round(30 + rand() * 50),
+        });
+    }
+    return coalitions;
+}
+function generatePowerDynamics(agents, rand) {
+    const roles = ['driver', 'reactor', 'stabilizer', 'disruptor'];
+    const descriptions = {
+        driver: ['Sets the strategic direction; other agents respond to this agent\'s moves.', 'Primary initiator of action; shapes the competitive landscape.'],
+        reactor: ['Responds to others\' strategies rather than initiating; adaptive but not proactive.', 'Follows dominant trends; optimizes within established dynamics.'],
+        stabilizer: ['Acts as a moderating force; dampens oscillations and promotes equilibrium.', 'Consistently chooses cooperative strategies; anchors the system.'],
+        disruptor: ['Introduces unpredictability; breaks established patterns and forces adaptation.', 'High-variance strategy creates opportunities and threats for all agents.'],
+    };
+    return agents.map(agent => {
+        const role = roles[Math.floor(rand() * roles.length)];
+        const descs = descriptions[role];
+        return {
+            agent,
+            role,
+            influence: Math.round(20 + rand() * 75),
+            description: descs[Math.floor(rand() * descs.length)],
+        };
+    });
+}
+function generateEquilibrium(agents, rand) {
+    const types = [
+        { type: 'Nash Equilibrium', description: 'The system has reached a state where no agent can unilaterally improve their outcome by changing strategy. This equilibrium is self-enforcing but may not be globally optimal.' },
+        { type: 'Pareto Suboptimal Equilibrium', description: 'Agents are locked in a stable but collectively suboptimal state. A coordinated deviation could improve all agents\' outcomes, but individual incentives prevent it.' },
+        { type: 'Cyclical Dynamics', description: 'No stable equilibrium detected. The system oscillates between states as agents continuously adapt to each other\'s strategies.' },
+        { type: 'Mixed Strategy Equilibrium', description: 'Agents randomize between strategies with specific probabilities. The equilibrium is maintained through uncertainty rather than fixed strategies.' },
+    ];
+    const selected = types[Math.floor(rand() * types.length)];
+    const isStable = rand() > 0.4;
+    return {
+        isStable,
+        type: selected.type,
+        description: selected.description,
+        stabilityScore: Math.round(isStable ? 55 + rand() * 40 : 15 + rand() * 35),
+        vulnerabilities: [
+            'External shock could push agents to reassess strategies',
+            agents.length > 3 ? `Coalition between ${agents[0]} and ${agents[1]} could destabilize current equilibrium` : 'Small agent count increases sensitivity to individual strategy changes',
+            'Information asymmetry may be masking true strategic preferences',
+        ].slice(0, 2 + Math.floor(rand() * 2)),
+    };
+}
+function generateSwarmPaths(agents, rand) {
+    const pathOptions = [
+        { name: 'Coalition Reinforcement', description: 'Strengthen the dominant coalition by aligning incentives and reducing defection risk among members.' },
+        { name: 'Disruptor Containment', description: 'Isolate disruptive agents through coordinated exclusion or counter-strategies.' },
+        { name: 'Equilibrium Shift', description: 'Introduce strategic perturbation to move the system toward a more favorable equilibrium state.' },
+        { name: 'Cooperation Incentive Design', description: 'Restructure payoff matrices to make cooperation individually rational, not just collectively optimal.' },
+        { name: 'Adaptive Monitoring', description: 'Implement continuous strategy monitoring and adjust response in real-time based on agent behavior changes.' },
+    ];
+    let totalProb = 0;
+    const paths = pathOptions.map((p, i) => {
+        const prob = Math.round(15 + rand() * 30);
+        totalProb += prob;
+        return {
+            ...p,
+            probability: prob,
+            riskLevel: (rand() > 0.6 ? 'high' : rand() > 0.3 ? 'medium' : 'low'),
+            tradeoffs: [
+                `May alienate ${agents[Math.floor(rand() * agents.length)]}`,
+                'Requires sustained coordination to maintain effectiveness',
+                'Outcome depends on accurate agent behavior modeling',
+            ].slice(0, 2 + Math.floor(rand() * 2)),
+            recommended: i === 0,
+        };
+    });
+    paths.forEach(p => { p.probability = Math.round((p.probability / totalProb) * 100); });
+    return paths;
+}
+function generateSwarmMatrix(agents, paths, rand) {
+    const strategies = paths.slice(0, 3).map(p => p.name);
+    const reactions = agents.map(() => strategies.map(() => {
+        const r = rand();
+        return r > 0.55 ? 'positive' : r > 0.25 ? 'neutral' : 'negative';
+    }));
+    return { strategies, stakeholders: agents, reactions };
+}
+function generateSwarmOutcomes(rand) {
+    return [
+        { label: 'Best Case', type: 'best', conditions: 'All agents converge on cooperative equilibrium', description: 'System achieves globally optimal state; all agents benefit from sustained cooperation.', likelihood: Math.round(10 + rand() * 15), impactRating: Math.round(2 + rand() * 2) },
+        { label: 'Most Likely', type: 'likely', conditions: 'Partial cooperation with persistent free-riding', description: 'Dominant coalition maintains advantage while fringe agents exploit cooperative norms.', likelihood: Math.round(35 + rand() * 20), impactRating: Math.round(4 + rand() * 2) },
+        { label: 'Worst Case', type: 'worst', conditions: 'Coalition fracture and competitive spiral', description: 'Trust breakdown triggers mutual defection; system degrades to non-cooperative equilibrium.', likelihood: Math.round(10 + rand() * 15), impactRating: Math.round(7 + rand() * 2) },
+        { label: 'Tail Risk', type: 'tail', conditions: 'Emergent adversarial strategy defeats all known counters', description: 'Novel agent strategy exploits systemic vulnerability; cascading failures across the agent network.', likelihood: Math.round(2 + rand() * 8), impactRating: Math.round(9 + rand()) },
+    ];
+}
+function generateSwarmChallenges(agents, rand) {
+    const challenges = [
+        { assumption: 'Agents behave rationally', whyItMightFail: 'Bounded rationality, information delays, and emergent complexity produce behaviors that deviate from game-theoretic optimality.', whatChanges: 'Predictive models may fail; heuristic-based analysis becomes necessary.', severity: 'high' },
+        { assumption: 'Agent strategies are observable', whyItMightFail: 'Agents may employ deceptive signaling, masking true strategies behind observable actions.', whatChanges: 'Strategy inference requires deeper behavioral analysis; surface patterns may mislead.', severity: 'medium' },
+        { assumption: 'The environment is stationary', whyItMightFail: 'Payoff structures and constraints may shift during the simulation, invalidating equilibrium analysis.', whatChanges: 'Continuous recalibration needed; static equilibrium analysis insufficient.', severity: 'high' },
+        { assumption: `${agents[0]} will maintain current strategy`, whyItMightFail: 'Agents adapt over time; current strategy may be transitional rather than stable.', whatChanges: 'Must model strategy evolution, not just current state.', severity: 'medium' },
+        { assumption: 'Coalition structures are stable', whyItMightFail: 'Internal incentive misalignment may cause coalition fracture under pressure.', whatChanges: 'Coalition durability should be stress-tested; contingency plans for fracture needed.', severity: 'critical' },
+    ];
+    return challenges.slice(0, 3 + Math.floor(rand() * 3));
+}
+function generateSwarmRecommendations(agents, paths, rand) {
+    const rec = paths.find(p => p.recommended) || paths[0];
+    return [
+        { priority: 1, action: `Implement ${rec.name}`, rationale: `Highest-probability intervention (${rec.probability}%) for steering swarm behavior.`, timeframe: 'Immediate' },
+        { priority: 2, action: 'Monitor coalition stability metrics', rationale: 'Early detection of coalition fracture enables preemptive intervention.', timeframe: 'Continuous' },
+        { priority: 3, action: `Address ${agents[agents.length - 1]} behavior pattern`, rationale: 'Outlier agent behavior may indicate either exploitation or innovation; requires assessment.', timeframe: 'Within next cycle' },
+        { priority: 4, action: 'Run sensitivity analysis on payoff structure', rationale: 'Small payoff changes may trigger large behavioral shifts; identify critical thresholds.', timeframe: 'Before next iteration' },
+    ];
+}

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/utils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cn = cn;
+const clsx_1 = require("clsx");
+const tailwind_merge_1 = require("tailwind-merge");
+function cn(...inputs) {
+    return (0, tailwind_merge_1.twMerge)((0, clsx_1.clsx)(inputs));
+}