feat(minecraft): yet another overhaul...

i honestly don't know what to feel about this

Author: shinohara-rin

pnpm-lock.yaml

@@ -93,6 +93,7 @@ catalog:
   vue-sonner: 2.0.9
   ws: ^8.18.3
   xsschema: 0.4.0-beta.13
+  yaml: ^2.8.2
   zod: ^4.3.5
 
 catalogs:

pnpm-workspace.yaml

@@ -26,6 +26,7 @@
     "mineflayer-pathfinder": "^2.4.5",
     "mineflayer-pvp": "^1.3.2",
     "mineflayer-tool": "^1.2.0",
+    "nanoid": "catalog:",
     "neuri": "^0.2.1",
     "prismarine-block": "^1.22.0",
     "prismarine-entity": "^2.5.0",
@@ -37,6 +38,7 @@
     "vec3": "^0.1.10",
     "zod": "^4.3.5",
     "ws": "catalog:",
+    "yaml": "catalog:",
     "zod-to-json-schema": "^3.25.1"
   },
   "devDependencies": {

services/minecraft/package.json

@@ -1,6 +1,8 @@
 import type { Logg } from '@guiiai/logg'
 import type { Neuri } from 'neuri'
 
+import type { EventBus, RuleEngine } from './os'
+
 import { useLogg } from '@guiiai/logg'
 import { asClass, asFunction, createContainer, InjectionMode } from 'awilix'
 
@@ -9,12 +11,15 @@ import { ChatAgentImpl } from '../agents/chat'
 import { PlanningAgentImpl } from '../agents/planning'
 import { TaskExecutor } from './action/task-executor'
 import { Brain } from './conscious/brain'
+import { createEventBus, createRuleEngine } from './os'
 import { EventManager } from './perception/event-manager'
 import { PerceptionPipeline } from './perception/pipeline'
 import { ReflexManager } from './reflex/reflex-manager'
 
 export interface ContainerServices {
   logger: Logg
+  eventBus: EventBus
+  ruleEngine: RuleEngine
   actionAgent: ActionAgentImpl
   planningAgent: PlanningAgentImpl
   chatAgent: ChatAgentImpl
@@ -43,6 +48,28 @@ export function createAgentContainer(options: {
     // Register neuri client
     neuri: asFunction(() => options.neuri).singleton(),
 
+    // Register EventBus (Cognitive OS core)
+    eventBus: asFunction(() =>
+      createEventBus({
+        logger: useLogg('eventBus').useGlobalConfig(),
+        config: { historySize: 10000 },
+      }),
+    ).singleton(),
+
+    // Register RuleEngine (YAML rules processing)
+    ruleEngine: asFunction(({ eventBus }) => {
+      const engine = createRuleEngine({
+        eventBus,
+        logger: useLogg('ruleEngine').useGlobalConfig(),
+        config: {
+          rulesDir: new URL('../rules', import.meta.url).pathname,
+          slotMs: 20,
+        },
+      })
+      engine.init()
+      return engine
+    }).singleton(),
+
     // Register agents
     actionAgent: asClass(ActionAgentImpl)
       .singleton()

services/minecraft/src/cognitive/container.ts

@@ -2,6 +2,7 @@ import type { MineflayerPlugin } from '../libs/mineflayer'
 import type { CognitiveEngineOptions, MineflayerWithAgents } from './types'
 
 import { config } from '../composables/config'
+import { DebugService } from '../debug'
 import { ChatMessageHandler } from '../libs/mineflayer'
 import { createAgentContainer } from './container'
 import { createPerceptionFrameFromChat } from './perception/frame'
@@ -48,6 +49,21 @@ export function CognitiveEngine(options: CognitiveEngineOptions): MineflayerPlug
         // Initialize perception pipeline (raw events + detectors)
         perceptionPipeline.init(botWithAgents)
 
+        // Resolve EventBus and subscribe to forward events to debug timeline
+        const eventBus = container.resolve('eventBus')
+        eventBus.subscribe('*', (event) => {
+          // Forward to debug service for timeline visualization
+          DebugService.getInstance().emitTrace({
+            id: event.id,
+            traceId: event.traceId,
+            parentId: event.parentId,
+            type: event.type,
+            payload: event.payload,
+            timestamp: event.timestamp,
+            source: event.source,
+          })
+        })
+
         // Set message handling via EventManager
         const chatHandler = new ChatMessageHandler(bot.username)
         bot.bot.on('chat', (username, message) => {
@@ -79,6 +95,9 @@ export function CognitiveEngine(options: CognitiveEngineOptions): MineflayerPlug
         const perceptionPipeline = container.resolve('perceptionPipeline')
         perceptionPipeline.destroy()
 
+        const ruleEngine = container.resolve('ruleEngine')
+        ruleEngine.destroy()
+
         const reflexManager = container.resolve('reflexManager')
         reflexManager.destroy()
       }

services/minecraft/src/cognitive/index.ts

@@ -0,0 +1,242 @@
+import type { TracedEvent } from './types'
+
+import { useLogg } from '@guiiai/logg'
+import { describe, expect, it, vi } from 'vitest'
+
+import { createEventBus } from './index'
+
+describe('eventBus', () => {
+  const createTestBus = () =>
+    createEventBus({
+      logger: useLogg('test'),
+      config: { historySize: 100 },
+    })
+
+  describe('emit', () => {
+    it('should create an event with auto-generated id and timestamp', () => {
+      const bus = createTestBus()
+
+      const event = bus.emit({
+        type: 'test:event',
+        payload: { foo: 'bar' },
+        traceId: 'trace-1',
+        source: { component: 'test' },
+      })
+
+      expect(event.id).toBeDefined()
+      expect(event.id.length).toBe(12)
+      expect(event.traceId).toBe('trace-1')
+      expect(event.type).toBe('test:event')
+      expect(event.payload).toEqual({ foo: 'bar' })
+      expect(event.timestamp).toBeGreaterThan(0)
+    })
+
+    it('should generate traceId if not provided', () => {
+      const bus = createTestBus()
+
+      const event = bus.emit({
+        type: 'test:event',
+        payload: {},
+        source: { component: 'test' },
+      })
+
+      expect(event.traceId).toBeDefined()
+      expect(event.traceId.length).toBe(16)
+    })
+
+    it('should freeze the event (immutable)', () => {
+      const bus = createTestBus()
+
+      const event = bus.emit({
+        type: 'test:event',
+        payload: { mutable: 'data' },
+        source: { component: 'test' },
+      })
+
+      expect(Object.isFrozen(event)).toBe(true)
+      expect(Object.isFrozen(event.payload)).toBe(true)
+      expect(Object.isFrozen(event.source)).toBe(true)
+    })
+
+    it('should deep freeze nested objects in payload', () => {
+      const bus = createTestBus()
+
+      const event = bus.emit({
+        type: 'test:event',
+        payload: {
+          level1: {
+            level2: {
+              value: 42,
+            },
+          },
+          array: [{ item: 1 }, { item: 2 }],
+        },
+        source: { component: 'test' },
+      })
+
+      expect(Object.isFrozen(event.payload)).toBe(true)
+      expect(Object.isFrozen((event.payload as any).level1)).toBe(true)
+      expect(Object.isFrozen((event.payload as any).level1.level2)).toBe(true)
+      expect(Object.isFrozen((event.payload as any).array)).toBe(true)
+      expect(Object.isFrozen((event.payload as any).array[0])).toBe(true)
+    })
+  })
+
+  describe('emitChild', () => {
+    it('should inherit traceId and set parentId', () => {
+      const bus = createTestBus()
+
+      const parent = bus.emit({
+        type: 'parent:event',
+        payload: {},
+        source: { component: 'test' },
+      })
+
+      const child = bus.emitChild(parent, {
+        type: 'child:event',
+        payload: { derived: true },
+        source: { component: 'test' },
+      })
+
+      expect(child.traceId).toBe(parent.traceId)
+      expect(child.parentId).toBe(parent.id)
+    })
+  })
+
+  describe('subscribe', () => {
+    it('should call handler for matching events', () => {
+      const bus = createTestBus()
+      const handler = vi.fn()
+
+      bus.subscribe('test:event', handler)
+      bus.emit({
+        type: 'test:event',
+        payload: { data: 123 },
+        source: { component: 'test' },
+      })
+
+      expect(handler).toHaveBeenCalledTimes(1)
+      expect(handler.mock.calls[0][0].payload).toEqual({ data: 123 })
+    })
+
+    it('should support wildcard patterns', () => {
+      const bus = createTestBus()
+      const handler = vi.fn()
+
+      bus.subscribe('raw:*', handler)
+
+      bus.emit({
+        type: 'raw:sighted:punch',
+        payload: {},
+        source: { component: 'test' },
+      })
+      bus.emit({
+        type: 'raw:heard:sound',
+        payload: {},
+        source: { component: 'test' },
+      })
+      bus.emit({
+        type: 'signal:attention',
+        payload: {},
+        source: { component: 'test' },
+      })
+
+      expect(handler).toHaveBeenCalledTimes(2)
+    })
+
+    it('should return unsubscribe function', () => {
+      const bus = createTestBus()
+      const handler = vi.fn()
+
+      const unsub = bus.subscribe('test:*', handler)
+
+      bus.emit({
+        type: 'test:one',
+        payload: {},
+        source: { component: 'test' },
+      })
+      expect(handler).toHaveBeenCalledTimes(1)
+
+      unsub()
+
+      bus.emit({
+        type: 'test:two',
+        payload: {},
+        source: { component: 'test' },
+      })
+      expect(handler).toHaveBeenCalledTimes(1) // Still 1
+    })
+  })
+
+  describe('trace context propagation', () => {
+    it('should propagate trace context in handlers', () => {
+      const bus = createTestBus()
+      let childEvent: TracedEvent | undefined
+
+      bus.subscribe('parent:event', () => {
+        // Emit within handler - should inherit context
+        childEvent = bus.emit({
+          type: 'child:event',
+          payload: {},
+          source: { component: 'handler' },
+        })
+      })
+
+      const parent = bus.emit({
+        type: 'parent:event',
+        payload: {},
+        source: { component: 'test' },
+      })
+
+      expect(childEvent).toBeDefined()
+      expect(childEvent!.traceId).toBe(parent.traceId)
+      expect(childEvent!.parentId).toBe(parent.id)
+    })
+  })
+
+  describe('history', () => {
+    it('should store events in history', () => {
+      const bus = createTestBus()
+
+      bus.emit({ type: 'e1', payload: {}, source: { component: 'test' } })
+      bus.emit({ type: 'e2', payload: {}, source: { component: 'test' } })
+      bus.emit({ type: 'e3', payload: {}, source: { component: 'test' } })
+
+      const history = bus.getHistory()
+      expect(history.length).toBe(3)
+      expect(history[0].type).toBe('e1')
+      expect(history[2].type).toBe('e3')
+    })
+
+    it('should respect historySize limit (ring buffer)', () => {
+      const bus = createEventBus({
+        logger: useLogg('test'),
+        config: { historySize: 3 },
+      })
+
+      bus.emit({ type: 'e1', payload: {}, source: { component: 'test' } })
+      bus.emit({ type: 'e2', payload: {}, source: { component: 'test' } })
+      bus.emit({ type: 'e3', payload: {}, source: { component: 'test' } })
+      bus.emit({ type: 'e4', payload: {}, source: { component: 'test' } })
+
+      const history = bus.getHistory()
+      expect(history.length).toBe(3)
+      // Oldest event (e1) should be evicted
+      expect(history.map(e => e.type)).toEqual(['e2', 'e3', 'e4'])
+    })
+  })
+
+  describe('getEventsByTrace', () => {
+    it('should filter events by traceId', () => {
+      const bus = createTestBus()
+
+      const e1 = bus.emit({ type: 'a', payload: {}, source: { component: 'test' } })
+      bus.emitChild(e1, { type: 'b', payload: {}, source: { component: 'test' } })
+      bus.emit({ type: 'c', payload: {}, source: { component: 'test' } }) // Different trace
+
+      const trace = bus.getEventsByTrace(e1.traceId)
+      expect(trace.length).toBe(2)
+      expect(trace.map(e => e.type)).toEqual(['a', 'b'])
+    })
+  })
+})