378 lines
10 KiB
Python
378 lines
10 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
World Build Script for Timmy's Evennia World
|
|
Issue #83 — Scaffold the world
|
|
|
|
Run this script to create the initial world structure:
|
|
python evennia_launcher.py shell -f world/build.py
|
|
|
|
Or from in-game:
|
|
@py from world.build import build_world; build_world()
|
|
"""
|
|
|
|
from evennia import create_object, search_object
|
|
from evennia.utils import create
|
|
from typeclasses.rooms import Workshop, Library, Observatory, Forge, Dispatch
|
|
from typeclasses.characters import TimmyCharacter, KnowledgeItem, ToolObject, TaskObject
|
|
|
|
|
|
def build_world():
|
|
"""Build the complete Timmy world."""
|
|
|
|
print("Building Timmy's world...")
|
|
|
|
# Create rooms
|
|
workshop = _create_workshop()
|
|
library = _create_library()
|
|
observatory = _create_observatory()
|
|
forge = _create_forge()
|
|
dispatch = _create_dispatch()
|
|
|
|
# Connect rooms
|
|
_connect_rooms(workshop, library, observatory, forge, dispatch)
|
|
|
|
# Create Timmy character
|
|
timmy = _create_timmy(workshop)
|
|
|
|
# Populate with initial tools
|
|
_create_initial_tools(forge)
|
|
|
|
# Populate with sample knowledge
|
|
_create_sample_knowledge(library)
|
|
|
|
print("\nWorld build complete!")
|
|
print(f"Timmy is in: {timmy.location.name}")
|
|
print(f"Rooms created: Workshop, Library, Observatory, Forge, Dispatch")
|
|
|
|
return {
|
|
"timmy": timmy,
|
|
"workshop": workshop,
|
|
"library": library,
|
|
"observatory": observatory,
|
|
"forge": forge,
|
|
"dispatch": dispatch
|
|
}
|
|
|
|
|
|
def _create_workshop():
|
|
"""Create the Workshop room."""
|
|
workshop = create_object(
|
|
Workshop,
|
|
key="The Workshop",
|
|
desc="""|wThe Workshop|n
|
|
|
|
A clean, organized workspace with multiple stations:
|
|
- A terminal array for system operations
|
|
- A drafting table for architecture and design
|
|
- Tool racks along the walls
|
|
- A central workspace with holographic displays
|
|
|
|
This is where things get built.
|
|
|
|
Commands: read, write, search, git_*, sysinfo, think
|
|
"""
|
|
)
|
|
return workshop
|
|
|
|
|
|
def _create_library():
|
|
"""Create the Library room."""
|
|
library = create_object(
|
|
Library,
|
|
key="The Library",
|
|
desc="""|bThe Library|n
|
|
|
|
Floor-to-ceiling shelves hold knowledge items as glowing orbs:
|
|
- Optimization techniques sparkle with green light
|
|
- Architecture patterns pulse with blue energy
|
|
- Research papers rest in crystalline cases
|
|
- Best practices form organized stacks
|
|
|
|
A search terminal stands ready for queries.
|
|
|
|
Commands: search, study, learn
|
|
"""
|
|
)
|
|
return library
|
|
|
|
|
|
def _create_observatory():
|
|
"""Create the Observatory room."""
|
|
observatory = create_object(
|
|
Observatory,
|
|
key="The Observatory",
|
|
desc="""|mThe Observatory|n
|
|
|
|
A panoramic view of the infrastructure:
|
|
- Holographic dashboards float in the center
|
|
- System status displays line the walls
|
|
- Alert panels glow with current health
|
|
- A command console provides control
|
|
|
|
Everything is monitored from here.
|
|
|
|
Commands: health, status, metrics
|
|
"""
|
|
)
|
|
return observatory
|
|
|
|
|
|
def _create_forge():
|
|
"""Create the Forge room."""
|
|
forge = create_object(
|
|
Forge,
|
|
key="The Forge",
|
|
desc="""|rThe Forge|n
|
|
|
|
Heat and light emanate from working stations:
|
|
- A compiler array hums with activity
|
|
- Tool templates hang on the walls
|
|
- Test rigs verify each creation
|
|
- A deployment pipeline waits ready
|
|
|
|
Capabilities are forged here.
|
|
|
|
Commands: build, test, deploy
|
|
"""
|
|
)
|
|
return forge
|
|
|
|
|
|
def _create_dispatch():
|
|
"""Create the Dispatch room."""
|
|
dispatch = create_object(
|
|
Dispatch,
|
|
key="Dispatch",
|
|
desc="""|yDispatch|n
|
|
|
|
A command center for task management:
|
|
- Incoming task queue displays on the wall
|
|
- Routing assignments to different houses
|
|
- Priority indicators glow red/orange/green
|
|
- Status boards show current workload
|
|
|
|
Work flows through here.
|
|
|
|
Commands: tasks, assign, prioritize
|
|
"""
|
|
)
|
|
return dispatch
|
|
|
|
|
|
def _connect_rooms(workshop, library, observatory, forge, dispatch):
|
|
"""Create exits between rooms."""
|
|
|
|
# Workshop <-> Library
|
|
create_object(
|
|
"evennia.objects.objects.DefaultExit",
|
|
key="library",
|
|
aliases=["lib"],
|
|
location=workshop,
|
|
destination=library
|
|
)
|
|
create_object(
|
|
"evennia.objects.objects.DefaultExit",
|
|
key="workshop",
|
|
aliases=["work"],
|
|
location=library,
|
|
destination=workshop
|
|
)
|
|
|
|
# Workshop <-> Observatory
|
|
create_object(
|
|
"evennia.objects.objects.DefaultExit",
|
|
key="observatory",
|
|
aliases=["obs"],
|
|
location=workshop,
|
|
destination=observatory
|
|
)
|
|
create_object(
|
|
"evennia.objects.objects.DefaultExit",
|
|
key="workshop",
|
|
aliases=["work"],
|
|
location=observatory,
|
|
destination=workshop
|
|
)
|
|
|
|
# Workshop <-> Forge
|
|
create_object(
|
|
"evennia.objects.objects.DefaultExit",
|
|
key="forge",
|
|
location=workshop,
|
|
destination=forge
|
|
)
|
|
create_object(
|
|
"evennia.objects.objects.DefaultExit",
|
|
key="workshop",
|
|
aliases=["work"],
|
|
location=forge,
|
|
destination=workshop
|
|
)
|
|
|
|
# Workshop <-> Dispatch
|
|
create_object(
|
|
"evennia.objects.objects.DefaultExit",
|
|
key="dispatch",
|
|
aliases=["disp"],
|
|
location=workshop,
|
|
destination=dispatch
|
|
)
|
|
create_object(
|
|
"evennia.objects.objects.DefaultExit",
|
|
key="workshop",
|
|
aliases=["work"],
|
|
location=dispatch,
|
|
destination=workshop
|
|
)
|
|
|
|
print("Room connections created.")
|
|
|
|
|
|
def _create_timmy(starting_room):
|
|
"""Create the Timmy character."""
|
|
|
|
# Check if Timmy already exists
|
|
existing = search_object("Timmy", typeclass=TimmyCharacter)
|
|
if existing:
|
|
print("Timmy already exists, moving to workshop...")
|
|
timmy = existing[0]
|
|
timmy.move_to(starting_room)
|
|
return timmy
|
|
|
|
timmy = create_object(
|
|
TimmyCharacter,
|
|
key="Timmy",
|
|
location=starting_room,
|
|
desc="A sovereign AI, at your service.",
|
|
home=starting_room
|
|
)
|
|
|
|
# Set initial attributes
|
|
timmy.db.preferences = {
|
|
"coding_style": "clean, documented",
|
|
"verbosity": "concise",
|
|
"preferred_models": ["hermes4", "claude"],
|
|
"auto_execute_safe": True,
|
|
}
|
|
|
|
print(f"Timmy created in {starting_room.name}")
|
|
return timmy
|
|
|
|
|
|
def _create_initial_tools(forge):
|
|
"""Create initial tools in the Forge."""
|
|
|
|
tools = [
|
|
{
|
|
"name": "File Tool",
|
|
"type": "file",
|
|
"description": "Read, write, and search files"
|
|
},
|
|
{
|
|
"name": "Git Tool",
|
|
"type": "git",
|
|
"description": "Version control operations"
|
|
},
|
|
{
|
|
"name": "System Tool",
|
|
"type": "system",
|
|
"description": "System information and health checks"
|
|
},
|
|
{
|
|
"name": "Inference Tool",
|
|
"type": "inference",
|
|
"description": "Local LLM reasoning"
|
|
},
|
|
{
|
|
"name": "Gitea Tool",
|
|
"type": "gitea",
|
|
"description": "Issue and repository management"
|
|
}
|
|
]
|
|
|
|
for tool_info in tools:
|
|
tool = create_object(
|
|
ToolObject,
|
|
key=tool_info["name"],
|
|
location=forge,
|
|
desc=tool_info["description"]
|
|
)
|
|
tool.db.tool_type = tool_info["type"]
|
|
forge.register_tool(tool)
|
|
|
|
print(f"Created {len(tools)} initial tools.")
|
|
|
|
|
|
def _create_sample_knowledge(library):
|
|
"""Create sample knowledge items."""
|
|
|
|
items = [
|
|
{
|
|
"name": "Speculative Decoding",
|
|
"summary": "Use a small draft model to propose tokens, verify with large model for 2-3x speedup",
|
|
"source": "llama.cpp documentation",
|
|
"tags": ["inference", "optimization"],
|
|
"actions": [
|
|
"Download Qwen-2.5 0.5B GGUF (~400MB)",
|
|
"Configure llama-server with --draft-max 8",
|
|
"Benchmark against baseline",
|
|
"Monitor for quality degradation"
|
|
]
|
|
},
|
|
{
|
|
"name": "KV Cache Reuse",
|
|
"summary": "Cache the KV state for system prompts to avoid re-processing on every request",
|
|
"source": "llama.cpp --slot-save-path",
|
|
"tags": ["inference", "optimization", "caching"],
|
|
"actions": [
|
|
"Process system prompt once on startup",
|
|
"Save KV cache state",
|
|
"Load from cache for new requests",
|
|
"Expect 50-70% faster time-to-first-token"
|
|
]
|
|
},
|
|
{
|
|
"name": "Tool Result Caching",
|
|
"summary": "Cache stable tool outputs like git_status and system_info with TTL",
|
|
"source": "Issue #103",
|
|
"tags": ["caching", "optimization", "tools"],
|
|
"actions": [
|
|
"Check cache before executing tool",
|
|
"Use TTL per tool type (30s-300s)",
|
|
"Invalidate on write operations",
|
|
"Track hit rate > 30%"
|
|
]
|
|
},
|
|
{
|
|
"name": "Prompt Tiers",
|
|
"summary": "Route tasks to appropriate prompt complexity: reflex < standard < deep",
|
|
"source": "Issue #88",
|
|
"tags": ["prompting", "optimization"],
|
|
"actions": [
|
|
"Classify incoming tasks by complexity",
|
|
"Reflex: simple file reads (500 tokens)",
|
|
"Standard: multi-step tasks (1500 tokens)",
|
|
"Deep: analysis and debugging (full context)"
|
|
]
|
|
}
|
|
]
|
|
|
|
for item_info in items:
|
|
item = create_object(
|
|
KnowledgeItem,
|
|
key=item_info["name"],
|
|
location=library,
|
|
desc=f"Knowledge: {item_info['summary']}"
|
|
)
|
|
item.db.summary = item_info["summary"]
|
|
item.db.source = item_info["source"]
|
|
item.db.tags = item_info["tags"]
|
|
item.db.actions = item_info["actions"]
|
|
library.add_knowledge_item(item)
|
|
|
|
print(f"Created {len(items)} sample knowledge items.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
build_world()
|