import { World } from '@v1b3x0r/mds-core'

const world = new World({ features: { ontology: true } })

const npc = world.spawn({
  essence: 'Blacksmith who holds grudges',
  emotion: {
    transitions: [
      { trigger: 'player.attack', to: 'anger', intensity: 0.9 }
    ]
  },
  dialogue: {
    intro: [{ lang: { en: 'What do you want?' } }],
    onPlayerAttack: [{ lang: { en: 'You dare?!' } }]
  }
}, 200, 200)

// Before attack
console.log(npc.speak('intro'))  // → "What do you want?"

// Player attacks
npc.updateTriggerContext({ playerAction: 'attack' })
npc.checkEmotionTriggers()

// After attack
console.log('Mood:', npc.emotion.valence)  // → -0.54 (angry!)
console.log(npc.speak('onPlayerAttack'))   // → "You dare?!"

// Next session (saved/loaded)
const memories = npc.memory.recall({ type: 'interaction' })
console.log('NPC remembers', memories.length, 'interactions')
// NPC still remembers. Forever.

world.start()

import { World, resonate } from '@v1b3x0r/mds-core'

const world = new World({ features: { ontology: true } })

// Classroom simulation: 1 happy student, 2 neutral
const alice = world.spawn({ $schema: 'mdspec/v5.0', essence: 'Happy student' }, 100, 100)
const bob = world.spawn({ $schema: 'mdspec/v5.0', essence: 'Neutral student' }, 150, 100)
const charlie = world.spawn({ $schema: 'mdspec/v5.0', essence: 'Neutral student' }, 200, 100)

alice.emotion.valence = 0.8   // Happy
bob.emotion.valence = 0.0     // Neutral
charlie.emotion.valence = 0.0 // Neutral

// Form social network (students sitting near each other)
alice.connectTo(bob, { strength: 0.9 })
bob.connectTo(charlie, { strength: 0.8 })

// Simulate classroom session (happiness spreads over time)
setInterval(() => {
  resonate(bob.emotion, alice.emotion, 0.1)      // Bob catches Alice's mood
  resonate(charlie.emotion, bob.emotion, 0.1)    // Charlie catches Bob's mood

  console.log('Alice:', alice.emotion.valence.toFixed(2))    // 0.80 (stays happy)
  console.log('Bob:', bob.emotion.valence.toFixed(2))        // 0.45 (gets happier)
  console.log('Charlie:', charlie.emotion.valence.toFixed(2)) // 0.23 (also affected)
}, 1000)

world.start()

// After 30 seconds:
// Alice: 0.80 (source of happiness)
// Bob: 0.45 (infected by Alice)
// Charlie: 0.23 (secondary infection)

import { MemoryLog } from '@v1b3x0r/mds-core'

// Agent A observes sunrise
const agentA = new MemoryLog('agent-a')
agentA.append({
  timestamp: 0,
  type: 'observation',
  subject: 'world',
  content: { event: 'sunrise', beauty: 0.9 },
  salience: 0.8
})

// Agent B observes Agent A
const agentB = new MemoryLog('agent-b')
agentB.append({
  timestamp: 1,
  type: 'interaction',
  subject: 'agent-a',
  content: { greeting: 'Hello!' },
  salience: 0.7
})

// CRDT merge (zero conflicts, deterministic)
const result = agentA.merge(agentB)

console.log('Agent A memories:', agentA.size())  // → 2
console.log('Conflicts:', result.conflicts)      // → 0 (always!)
console.log('Added:', result.added)              // → 1

// Merge 100 times → same result (idempotent)
for (let i = 0; i < 100; i++) {
  agentA.merge(agentB)
}
console.log('Agent A memories:', agentA.size())  // → 2 (still!)

// Causal ordering preserved (vector clocks)
const memories = agentA.getMemories()
console.log(memories.map(m => m.content))
// → [{ event: 'sunrise', beauty: 0.9 }, { greeting: 'Hello!' }]

import { World, CognitiveNetwork } from '@v1b3x0r/mds-core'

const world = new World({ features: { ontology: true } })

// Spawn 50 users
const users = []
for (let i = 0; i < 50; i++) {
  const user = world.spawn({
    $schema: 'mdspec/v5.0',
    essence: `User ${i}`
  }, Math.random() * 800, Math.random() * 600)
  users.push(user)
}

// Build Small-World network (Watts-Strogatz)
const network = new CognitiveNetwork({ k: 6, p: 0.15 })
network.build(users)

// Each user connects to 6 neighbors + occasional long-range shortcuts
users.forEach(user => {
  console.log(`${user.m.essence}: ${user.getCognitiveLinksCount()} connections`)
})

// Get network stats
const stats = network.getStats()
console.log('Network size:', stats.nodeCount)
console.log('Total edges:', stats.edgeCount)
console.log('Avg degree:', stats.averageDegree)
console.log('Clustering:', stats.clusteringCoefficient)

// Periodic rewiring (simulate friend dynamics)
setInterval(() => {
  network.rewire(0.1)  // Rewire 10% of edges
  console.log('Network reshuffled!')
}, 30000)

world.start()

import { TrustSystem } from '@v1b3x0r/mds-core'

const trust = new TrustSystem({
  initialTrust: 0.5,
  trustThreshold: 0.6
})

// Entity decides what to share (privacy policies)
trust.setSharePolicy('memory', 'trust')    // Only share memories with trusted entities
trust.setSharePolicy('emotion', 'public')  // Share emotions freely
trust.setSharePolicy('intent', 'contextual') // Share goals only if important
trust.setSharePolicy('location', 'never')   // Never share location

// Interaction loop
trust.updateTrust('alice', +0.1)  // Positive interaction
trust.updateTrust('eve', -0.2)    // Negative interaction (deception detected)

// Check if should share data
console.log(trust.shouldShare('memory', 'alice'))  // → true (trust >= 0.6)
console.log(trust.shouldShare('memory', 'eve'))    // → false (trust < 0.6)
console.log(trust.shouldShare('emotion', 'eve'))   // → true (public policy)
console.log(trust.shouldShare('location', 'alice')) // → false (never policy)

// Get reputation stats
const stats = trust.getStats()
console.log('Trusted entities:', stats.trustedCount)
console.log('Untrusted entities:', stats.untrustedCount)
console.log('Average trust:', stats.averageTrust)

// Trust decays naturally over time (no interaction = forgot)
trust.decayTrust(10)  // 10 seconds passed

// World
const world = new World({
  features: {
    ontology: true,      // Memory/Emotion/Intent
    communication: true, // Dialogue/Messages
    cognitive: true,     // Learning/Skills
    cognition: true      // P2P systems (NEW v5.5)
  },
  cognition: {
    network: { k: 8, p: 0.2 },         // Small-World config
    trust: { initialTrust: 0.5 },      // Trust config
    resonance: { decayRate: 0.2 }      // Signal decay
  }
})

// Entity
const entity = world.spawn(material, x, y)
entity.enable('memory', 'learning', 'relationships')  // Unified API
entity.speak('intro')                                 // Multilingual
entity.remember({ type: 'interaction', ... })         // Memory
entity.connectTo(other, { strength: 0.8 })           // Cognitive link
entity.reinforceLink(other.id, 0.1)                  // Strengthen bond
entity.decayCognitiveLinks(dt, 0.01)                 // Natural forgetting

// P2P Cognition (v5.5)
import { CognitiveNetwork, ResonanceField, TrustSystem, MemoryLog, resonate } from '@v1b3x0r/mds-core'

const network = new CognitiveNetwork({ k: 8, p: 0.2 })
network.build(entities)
network.rewire(0.1)

const field = new ResonanceField({ decayRate: 0.2, minStrength: 0.1 })
field.propagate(signal, source, entities)

const trust = new TrustSystem()
trust.setSharePolicy('memory', 'trust')
trust.shouldShare('memory', targetId)

const log = new MemoryLog(entityId)
log.append(memory)
log.merge(otherLog)

resonate(self.emotion, other.emotion, 0.5)  // Emotional contagion

// Save/Load
const snapshot = world.saveWorldFile()
const restored = World.loadWorldFile(snapshot)

import { World, LanguageGenerator } from '@v1b3x0r/mds-core'

const world = new World({
  features: { communication: true, languageGeneration: true },
  llm: {
    provider: 'openrouter',  // or 'anthropic' | 'openai' | 'mock'
    apiKey: process.env.OPENROUTER_KEY,
    languageModel: 'anthropic/claude-3.5-sonnet'
  }
})

const llm = new LanguageGenerator({
  provider: world.llm?.provider,
  apiKey: world.llm?.apiKey,
  model: world.llm?.languageModel
})

const response = await llm.generate({
  speaker: npc,
  listener: player,
  context: 'Player helped NPC escape danger',
  tone: 'grateful',
  emotion: npc.emotion
})

console.log(response.text)
// → "Thank you, friend. I won't forget this kindness."

if (player.near(npc) && npc.remembers(player) && player.attackedBefore) {
  npc.mood = "angry"
  npc.say("You again?!")
}
// 500 lines of if-statements