""" Simu — MSKit's built-in AI assistant. Startup flow (fires before the very first simulation): Step 1 — Choose AI Brain: ┌──────────────────────────────────────────────────────────────┐ │ 1. untrained — Rule-based parser, instant, no download │ │ 2. huggingface — SmolLM2-360M-Instruct (recommended) │ │ 3. custom — Your own HF repo / local folder / .gguf │ └──────────────────────────────────────────────────────────────┘ Step 2 — Choose Simulation Mode: ┌──────────────────────────────────────────────────────────────┐ │ 1. random — Simu picks a random simulation for you │ │ 2. custom — You describe exactly what you want │ │ 3. everything — Run ALL 6 simulations at once │ └──────────────────────────────────────────────────────────────┘ Both selections are remembered for the session. Type 'switch brain' or 'switch sim' at any time to change. """ from __future__ import annotations import os import re import json import random import textwrap from contextlib import contextmanager, redirect_stderr, redirect_stdout from pathlib import Path from typing import Any, Dict, List, Optional, Tuple import numpy as np from .intent import parse_intent, CITIES # --------------------------------------------------------------------------- # Constants # --------------------------------------------------------------------------- HF_MODEL_ID = "HuggingFaceTB/SmolLM2-360M-Instruct" MAX_NEW_TOKENS = 512 TEMPERATURE = 0.3 # All simulation types Simu can run ALL_SIM_TYPES = [ "random_walk", "projectile", "water_flow", "agent", "traffic", "profile", ] # --------------------------------------------------------------------------- # Brain mode constants + aliases # --------------------------------------------------------------------------- MODE_UNTRAINED = "untrained" MODE_HUGGINGFACE = "huggingface" MODE_CUSTOM = "custom" _BRAIN_ALIASES: Dict[str, str] = { "untrained": MODE_UNTRAINED, "rules": MODE_UNTRAINED, "rule": MODE_UNTRAINED, "fast": MODE_UNTRAINED, "1": MODE_UNTRAINED, "huggingface": MODE_HUGGINGFACE, "hf": MODE_HUGGINGFACE, "smollm": MODE_HUGGINGFACE, "smollm2": MODE_HUGGINGFACE, "2": MODE_HUGGINGFACE, "custom": MODE_CUSTOM, "upload": MODE_CUSTOM, "my": MODE_CUSTOM, "own": MODE_CUSTOM, "3": MODE_CUSTOM, } # --------------------------------------------------------------------------- # Simulation mode constants + aliases # --------------------------------------------------------------------------- SIMMODE_RANDOM = "random" SIMMODE_CUSTOM = "custom" SIMMODE_EVERYTHING = "everything" _SIMMODE_ALIASES: Dict[str, str] = { "random": SIMMODE_RANDOM, "rand": SIMMODE_RANDOM, "surprise": SIMMODE_RANDOM, "random simulation": SIMMODE_RANDOM, "1": SIMMODE_RANDOM, "custom": SIMMODE_CUSTOM, "describe": SIMMODE_CUSTOM, "manual": SIMMODE_CUSTOM, "choose": SIMMODE_CUSTOM, "specific": SIMMODE_CUSTOM, "2": SIMMODE_CUSTOM, "everything": SIMMODE_EVERYTHING, "all": SIMMODE_EVERYTHING, "every": SIMMODE_EVERYTHING, "all sims": SIMMODE_EVERYTHING, "run all": SIMMODE_EVERYTHING, "3": SIMMODE_EVERYTHING, } # --------------------------------------------------------------------------- # Banners # --------------------------------------------------------------------------- _BRAIN_BANNER = """ ╔══════════════════════════════════════════════════════════════╗ ║ 🤖 Simu — Step 1: Choose Your AI Brain ║ ╠══════════════════════════════════════════════════════════════╣ ║ ║ ║ 1. untrained — Rule-based parser. Instant, no download. ║ ║ Great for clear, direct requests. ║ ║ ║ ║ 2. huggingface — SmolLM2-360M-Instruct ★ recommended ★ ║ ║ Open-source LLM, ~700 MB, CPU-capable. ║ ║ Handles complex / ambiguous language. ║ ║ ║ ║ 3. custom — Your own model. ║ ║ HuggingFace repo ID, local folder, ║ ║ or a .gguf file path. ║ ║ ║ ╚══════════════════════════════════════════════════════════════╝ Type the name or number (untrained / huggingface / custom): """ _SIMMODE_BANNER = """ ╔══════════════════════════════════════════════════════════════╗ ║ 🎮 Simu — Step 2: Choose Simulation Mode ║ ╠══════════════════════════════════════════════════════════════╣ ║ ║ ║ 1. random — Simu surprises you! ║ ║ Picks a random simulation + location. ║ ║ ║ ║ 2. custom — You're in control. ║ ║ Describe exactly what you want in ║ ║ plain English and Simu will run it. ║ ║ ║ ║ 3. everything — Run them all. ║ ║ Simu runs all 6 simulations at once ║ ║ and returns every result. ║ ║ ║ ╚══════════════════════════════════════════════════════════════╝ Type the name or number (random / custom / everything): """ _SIMU_SYSTEM_PROMPT = """\ You are Simu, the AI assistant embedded in MSKit (Mini Simulation Kit). MSKit runs terrain simulations on real-world JAXA AW3D30 elevation data and live traffic from OpenTraffic + UTD19. Understand what simulation the user wants and reply with: 1. A short friendly explanation of what you will run. 2. A JSON block (```json ... ```) with simulation parameters. Simulations available: random_walk — slope-biased terrain walk projectile — ballistic trajectory over terrain water_flow — D8 runoff routing agent — RL terrain-navigating agent traffic — road speed / congestion query profile — elevation cross-section between two points JSON schema: { "sim_type": "random_walk", "location": {"lat": 35.68, "lon": 139.69, "name": "Tokyo"}, "params": {"steps": 500}, "explanation": "Running a 500-step walk in Tokyo." } Be friendly, concise, and accurate. You are Simu! """ # --------------------------------------------------------------------------- # Helpers # --------------------------------------------------------------------------- @contextmanager def _quiet(): with open(os.devnull, "w") as devnull: with redirect_stdout(devnull), redirect_stderr(devnull): yield def _is_gguf(path: str) -> bool: try: with open(path, "rb") as f: return f.read(4) == b"GGUF" except Exception: return False def _random_location() -> Dict[str, Any]: """Pick a random city from the known list.""" name = random.choice(list(CITIES.keys())) lat, lon = CITIES[name] return {"lat": lat, "lon": lon, "name": name.title()} def _random_params(sim_type: str) -> Dict[str, Any]: """Generate sensible random params for a sim type.""" if sim_type == "random_walk": return {"steps": random.choice([200, 300, 500, 1000]), "slope_bias": round(random.uniform(0.2, 0.9), 2)} if sim_type == "projectile": return {"elevation_deg": random.choice([15, 30, 45, 60, 75]), "azimuth_deg": random.choice([0, 45, 90, 135, 180, 270]), "speed_ms": random.choice([40, 60, 80, 100, 120])} if sim_type == "water_flow": return {"patch_km": random.choice([3, 5, 8, 10]), "steps": random.choice([1000, 3000, 5000])} if sim_type == "agent": return {"steps": random.choice([100, 200, 300])} if sim_type == "traffic": return {} if sim_type == "profile": return {"steps": random.choice([100, 200])} return {} # --------------------------------------------------------------------------- # Simu # --------------------------------------------------------------------------- class Simu: """ Simu — MSKit's AI assistant. Startup sequence (fires before the first simulation): 1. Brain selection — untrained / huggingface / custom 2. Simulation mode — random / custom / everything Parameters ---------- dem_loader : DEMLoader, optional traffic_router : TrafficRouter, optional verbose : bool auto_select : str, optional Pre-select brain ("untrained" | "huggingface" | "custom"). auto_simmode : str, optional Pre-select sim mode ("random" | "custom" | "everything"). custom_model : str, optional Model path/repo for custom brain mode. Examples -------- >>> from mskit import Simu >>> simu = Simu() # full interactive startup >>> simu = Simu(auto_select="untrained", auto_simmode="custom") >>> simu = Simu(auto_select="huggingface", auto_simmode="everything") >>> result = simu.chat("Random walk in Tokyo for 500 steps") >>> results = simu.run_all("Mount Fuji") # everything mode helper """ def __init__( self, dem_loader=None, traffic_router=None, verbose: bool = True, auto_select: Optional[str] = None, auto_simmode: Optional[str] = None, custom_model: Optional[str] = None, ): self._dem = dem_loader self._traffic = traffic_router self._verbose = verbose self._model = None self._tokenizer = None self._brain_mode: Optional[str] = None self._sim_mode: Optional[str] = None self._model_label = "none" self._history: List[Dict[str, str]] = [] self._ready = False self._custom_model_path: Optional[str] = custom_model # Pre-select both if given _brain = _BRAIN_ALIASES.get((auto_select or "").lower().strip()) _smode = _SIMMODE_ALIASES.get((auto_simmode or "").lower().strip()) if _brain: self._apply_brain(_brain, custom_model) if _smode: self._sim_mode = _smode if _brain and _smode: self._ready = True # ------------------------------------------------------------------ # Public API # ------------------------------------------------------------------ def chat(self, message: str) -> Dict[str, Any]: """ Send a natural language message to Simu. In 'random' sim mode → ignores your text, picks a random sim. In 'custom' sim mode → uses your description to pick the sim. In 'everything' sim mode → runs all 6 sims, uses your location hint. """ if not self._ready: self._startup() # ── random mode: ignore user text, surprise them ────────────── if self._sim_mode == SIMMODE_RANDOM: return self._run_random_surprise() # ── everything mode: run all 6 at once ──────────────────────── if self._sim_mode == SIMMODE_EVERYTHING: return self._run_everything(message) # ── custom mode: NLU → dispatch ─────────────────────────────── self._print(f"\n💬 You: {message}") intent, response_text, source = self._understand(message) self._print(f"\n🤖 Simu: {response_text}\n") self._print(f" → Sim : {intent['sim_type']} @ {intent['location']['name']}") self._print(f" → Params : {intent['params']}") self._print(f" → Conf : {intent['confidence']:.0%}" f" [brain: {self._brain_mode}/{self._model_label}]" f" [mode: {self._sim_mode}]") output = None if self._dem is not None or intent["sim_type"] == "traffic": output = self._dispatch(intent) if output and self._verbose: self._print(f" → Result : {self._summarise(output)}") self._history.append({"role": "user", "content": message}) self._history.append({"role": "assistant", "content": response_text}) return { "intent": intent, "response": response_text, "output": output, "source": source, "brain": self._brain_mode, "sim_mode": self._sim_mode, } def run(self, description: str) -> Dict[str, Any]: """Alias for chat().""" return self.chat(description) def run_all(self, location_hint: str = "Tokyo") -> Dict[str, Any]: """Shortcut: run all 6 simulations for a given location.""" old_mode = self._sim_mode self._sim_mode = SIMMODE_EVERYTHING result = self._run_everything(location_hint) self._sim_mode = old_mode return result def select_brain(self, mode: str, custom_model: Optional[str] = None): """Programmatically select a brain.""" resolved = _BRAIN_ALIASES.get(mode.lower().strip(), mode.lower().strip()) self._apply_brain(resolved, custom_model) def select_sim_mode(self, mode: str): """Programmatically select a simulation mode.""" resolved = _SIMMODE_ALIASES.get(mode.lower().strip(), mode.lower().strip()) if resolved not in (SIMMODE_RANDOM, SIMMODE_CUSTOM, SIMMODE_EVERYTHING): raise ValueError(f"Unknown sim mode '{mode}'. " "Use: random / custom / everything") self._sim_mode = resolved self._print(f"✅ Simu: Simulation mode set to '{resolved}'.\n") def switch_brain(self): """Re-run brain selection interactively.""" self._brain_mode = None self._model = None self._tokenizer = None self._ready = False self._startup() def switch_sim_mode(self): """Re-run simulation mode selection interactively.""" self._sim_mode = None self._select_sim_mode() def help(self) -> str: msg = textwrap.dedent(f""" ╔══════════════════════════════════════════════════════╗ ║ Hi! I'm Simu 👋 ║ ║ MSKit's AI simulation assistant ║ ╚══════════════════════════════════════════════════════╝ Brain : {self._brain_mode or 'not selected'} ({self._model_label}) Sim mode : {self._sim_mode or 'not selected'} Simulation modes: random → Simu picks a surprise sim + random location custom → You describe what you want in plain English everything → All 6 sims run at once (just give a location) Sims available: random_walk · projectile · water_flow agent · traffic · profile Example phrases (custom mode): "Random walk in Tokyo for 1000 steps" "Shoot a projectile from Mount Fuji east at 45° 80 m/s" "Water flow in Zurich" "Traffic in London" "Agent from 35.6,139.7 to 35.65,139.75" "Elevation profile between Berlin and Munich" Commands: switch brain → re-pick AI model switch sim → re-pick simulation mode help → this message quit → exit """) print(msg) return msg def reset(self): """Clear conversation history (keeps brain + mode).""" self._history = [] # ------------------------------------------------------------------ # Startup sequence # ------------------------------------------------------------------ def _startup(self): """Run both selection steps in order.""" if self._brain_mode is None: self._select_brain() if self._sim_mode is None: self._select_sim_mode() self._ready = True # ── Step 1: Brain ───────────────────────────────────────────────── def _select_brain(self): print(_BRAIN_BANNER, flush=True) while True: try: raw = input("› ").strip().lower() except (EOFError, KeyboardInterrupt): raw = "untrained" mode = _BRAIN_ALIASES.get(raw) if mode is None: print(f" ❌ '{raw}' not recognised. " "Type: untrained, huggingface, or custom.") continue if mode == MODE_CUSTOM: path = self._ask_custom_model() self._apply_brain(MODE_CUSTOM, path) else: self._apply_brain(mode, None) break def _ask_custom_model(self) -> str: print(""" ┌─ Custom Model ──────────────────────────────────────────────┐ │ Enter ONE of: │ │ • HuggingFace repo ID e.g. mistralai/Mistral-7B-... │ │ • Local folder path e.g. /home/you/my-model/ │ │ • Local .gguf file e.g. /home/you/mistral.gguf │ └─────────────────────────────────────────────────────────────┘""") while True: try: raw = input(" Model path / repo › ").strip() except (EOFError, KeyboardInterrupt): return "" if raw: return raw print(" Please enter a value (Ctrl+C to cancel and use untrained).") # ── Step 2: Simulation mode ──────────────────────────────────────── def _select_sim_mode(self): print(_SIMMODE_BANNER, flush=True) while True: try: raw = input("› ").strip().lower() except (EOFError, KeyboardInterrupt): raw = "custom" mode = _SIMMODE_ALIASES.get(raw) if mode is None: print(f" ❌ '{raw}' not recognised. " "Type: random, custom, or everything.") continue self._sim_mode = mode labels = { SIMMODE_RANDOM: "Simu will surprise you with a random simulation!", SIMMODE_CUSTOM: "Describe what you want and I'll run it.", SIMMODE_EVERYTHING: "I'll run ALL 6 simulations at once!", } self._print(f"\n✅ Simu: {labels[mode]}\n") break # ------------------------------------------------------------------ # Brain loaders # ------------------------------------------------------------------ def _apply_brain(self, mode: str, custom_path: Optional[str] = None): self._brain_mode = mode if mode == MODE_UNTRAINED: self._model = None self._tokenizer = None self._model_label = "rule-based" self._print("\n✅ Simu: Rule-based brain ready — no download needed.\n") elif mode == MODE_HUGGINGFACE: self._model_label = HF_MODEL_ID self._print(f"\n🔽 Simu: Downloading {HF_MODEL_ID} (~700 MB on first run)...\n") self._load_transformers(HF_MODEL_ID) elif mode == MODE_CUSTOM: if not custom_path: self._print("⚠️ No model path given — falling back to untrained.\n") self._apply_brain(MODE_UNTRAINED) return self._model_label = custom_path if custom_path.endswith(".gguf") or ( Path(custom_path).is_file() and _is_gguf(custom_path) ): self._print(f"\n🔽 Simu: Loading GGUF '{Path(custom_path).name}'...\n") self._load_gguf(custom_path) else: self._print(f"\n🔽 Simu: Loading HF model '{custom_path}'...\n") self._load_transformers(custom_path) def _load_transformers(self, model_id: str): try: import torch from transformers import AutoTokenizer, AutoModelForCausalLM token = os.environ.get("HF_TOKEN") with _quiet(): tok = AutoTokenizer.from_pretrained(model_id, token=token) mdl = AutoModelForCausalLM.from_pretrained( model_id, token=token, torch_dtype=torch.float32, low_cpu_mem_usage=True, ) mdl.eval() self._tokenizer = tok self._model = mdl self._model_label = model_id self._print(f"✅ Simu: '{model_id}' loaded and ready!\n") except ImportError: self._print("⚠️ 'transformers' not installed — run: pip install mskit[llm]") self._print(" Falling back to rule-based.\n") self._brain_mode = MODE_UNTRAINED except Exception as e: self._print(f"⚠️ Could not load '{model_id}': {e}") self._print(" Falling back to rule-based.\n") self._brain_mode = MODE_UNTRAINED def _load_gguf(self, gguf_path: str): try: from llama_cpp import Llama with _quiet(): self._model = Llama(model_path=gguf_path, n_ctx=2048, verbose=False) self._model_label = Path(gguf_path).name self._brain_mode = f"{MODE_CUSTOM}:gguf" self._print(f"✅ Simu: GGUF '{Path(gguf_path).name}' loaded!\n") except ImportError: self._print("⚠️ 'llama-cpp-python' not installed — run: pip install mskit[gguf]") self._print(" Falling back to rule-based.\n") self._brain_mode = MODE_UNTRAINED except Exception as e: self._print(f"⚠️ Could not load GGUF: {e}") self._print(" Falling back to rule-based.\n") self._brain_mode = MODE_UNTRAINED # ------------------------------------------------------------------ # Simulation mode runners # ------------------------------------------------------------------ def _run_random_surprise(self) -> Dict[str, Any]: """Pick a random sim type + random city and run it.""" sim_type = random.choice(ALL_SIM_TYPES) location = _random_location() params = _random_params(sim_type) self._print(f"\n🎲 Simu: Surprise! Running a {sim_type.replace('_',' ')} " f"simulation at {location['name']}...") self._print(f" → Params : {params}\n") intent = { "sim_type": sim_type, "location": location, "params": params, "confidence": 1.0, "raw": "(random)", "explanation": f"Random {sim_type} at {location['name']}.", } output = None if self._dem is not None or sim_type == "traffic": output = self._dispatch(intent) if output and self._verbose: self._print(f" → Result : {self._summarise(output)}") return { "intent": intent, "response": f"🎲 Ran a random {sim_type.replace('_',' ')} at {location['name']}!", "output": output, "source": "random", "brain": self._brain_mode, "sim_mode": self._sim_mode, } def _run_everything(self, message: str) -> Dict[str, Any]: """Run all 6 simulations. Location extracted from message or random.""" from .intent import _find_location loc = _find_location(message) or _random_location() self._print(f"\n🌍 Simu: Running ALL 6 simulations at {loc['name']}...\n") results: Dict[str, Any] = {} summary_lines = [] for sim_type in ALL_SIM_TYPES: params = _random_params(sim_type) # For agent: set target ~5km northeast if sim_type == "agent": params["target_lat"] = loc["lat"] + 0.045 params["target_lon"] = loc["lon"] + 0.045 if sim_type == "profile": params["target_lat"] = loc["lat"] + 0.1 params["target_lon"] = loc["lon"] + 0.1 self._print(f" ▶ {sim_type:<12} ...", ) intent = { "sim_type": sim_type, "location": loc, "params": params, "confidence": 1.0, "raw": message, "explanation": f"{sim_type} at {loc['name']}.", } try: if self._dem is not None or sim_type == "traffic": output = self._dispatch(intent) else: output = {"note": "No DEM loader — params only", **params} results[sim_type] = output summary_lines.append(f" ✓ {sim_type:<12} {self._summarise(output)}") self._print(f" done — {self._summarise(output)}") except Exception as e: results[sim_type] = {"error": str(e)} summary_lines.append(f" ✗ {sim_type:<12} Error: {e}") self._print(f" ✗ Error: {e}") summary = "\n🏁 Simu: All done!\n" + "\n".join(summary_lines) self._print(summary) return { "intent": {"sim_type": "everything", "location": loc, "params": {}}, "response": summary, "output": results, "source": "everything", "brain": self._brain_mode, "sim_mode": self._sim_mode, } # ------------------------------------------------------------------ # NLU — LLM or rule-based # ------------------------------------------------------------------ def _understand(self, text: str) -> Tuple[Dict, str, str]: intent = parse_intent(text) if self._brain_mode and "gguf" in self._brain_mode and self._model: try: llm_intent, resp = self._gguf_understand(text, intent) return llm_intent, resp, "llm:gguf" except Exception as e: self._print(f" [GGUF error: {e} — using rules]") elif self._model is not None and self._tokenizer is not None: try: llm_intent, resp = self._transformers_understand(text, intent) return llm_intent, resp, "llm:transformers" except Exception as e: self._print(f" [LLM error: {e} — using rules]") return intent, self._rules_response(intent), "rules" def _transformers_understand(self, text: str, rule_intent: Dict) -> Tuple[Dict, str]: messages = [{"role": "system", "content": _SIMU_SYSTEM_PROMPT}] for turn in self._history[-4:]: messages.append(turn) messages.append({"role": "user", "content": text}) chat_text = self._tokenizer.apply_chat_template( messages, tokenize=False, add_generation_prompt=True, ) inputs = self._tokenizer(chat_text, return_tensors="pt") import torch with torch.no_grad(): out = self._model.generate( **inputs, max_new_tokens=MAX_NEW_TOKENS, temperature=TEMPERATURE, do_sample=True, pad_token_id=self._tokenizer.eos_token_id, ) new_tokens = out[0][inputs["input_ids"].shape[1]:] response = self._tokenizer.decode(new_tokens, skip_special_tokens=True).strip() return self._extract_json(response, rule_intent), response def _gguf_understand(self, text: str, rule_intent: Dict) -> Tuple[Dict, str]: messages = [{"role": "system", "content": _SIMU_SYSTEM_PROMPT}] for turn in self._history[-4:]: messages.append(turn) messages.append({"role": "user", "content": text}) out = self._model.create_chat_completion( messages=messages, max_tokens=MAX_NEW_TOKENS, temperature=TEMPERATURE, ) response = out["choices"][0]["message"]["content"].strip() return self._extract_json(response, rule_intent), response def _extract_json(self, response: str, fallback: Dict) -> Dict: m = re.search(r"```json\s*(\{.*?\})\s*```", response, re.DOTALL) if not m: m = re.search(r"\{[^{}]*\"sim_type\"[^{}]*\}", response, re.DOTALL) if not m: return fallback try: raw = m.group(1) if "```" in m.group(0) else m.group(0) data = json.loads(raw) intent = dict(fallback) intent["sim_type"] = data.get("sim_type", fallback["sim_type"]) if "location" in data: intent["location"] = data["location"] if "params" in data: intent["params"] = {**fallback["params"], **data["params"]} intent["confidence"] = min(fallback["confidence"] + 0.2, 1.0) return intent except (json.JSONDecodeError, KeyError): return fallback def _rules_response(self, intent: Dict) -> str: sim = intent["sim_type"].replace("_", " ") loc = intent["location"]["name"] params = intent["params"] lines = [f"Sure! Running a {sim} simulation at {loc}."] if params: lines.append("Parameters: " + ", ".join(f"{k}={v}" for k, v in params.items())) if intent["confidence"] < 0.6: lines.append("(Tip: try rephrasing if the result looks off!)") return " ".join(lines) # ------------------------------------------------------------------ # Simulation dispatcher # ------------------------------------------------------------------ def _dispatch(self, intent: Dict) -> Optional[Dict[str, Any]]: sim_type = intent["sim_type"] loc = intent["location"] params = intent.get("params", {}) lat, lon = loc["lat"], loc["lon"] try: fn = { "random_walk": self._run_random_walk, "projectile": self._run_projectile, "water_flow": self._run_water_flow, "agent": self._run_agent, "traffic": self._run_traffic, "profile": self._run_profile, }.get(sim_type) return fn(lat, lon, params) if fn else {"error": f"Unknown: {sim_type}"} except Exception as e: return {"error": str(e), "sim_type": sim_type} def _run_random_walk(self, lat, lon, params) -> Dict: from ..sims.random_walk import RandomWalk rw = RandomWalk(self._dem, lat, lon, step_m=params.get("step_m", 300), slope_bias=params.get("slope_bias", 0.5)) path = rw.run(steps=params.get("steps", 500)) return {"sim_type": "random_walk", "steps": len(path), "total_distance_km": round(rw.total_distance_km(), 3), "displacement_km": round(rw.displacement_km(), 3), "elevation_gain_m": round(rw.elevation_gain_m(), 1), "path_shape": list(rw.to_numpy().shape), "start": (lat, lon), "end": (path[-1][0], path[-1][1])} def _run_projectile(self, lat, lon, params) -> Dict: from ..sims.projectile import Projectile proj = Projectile(self._dem, lat, lon, azimuth_deg=params.get("azimuth_deg", 90), elevation_deg=params.get("elevation_deg", 45), speed_ms=params.get("speed_ms", 80), drag_coeff=params.get("drag_coeff", 0.0)) traj = proj.run() return {"sim_type": "projectile", "steps": len(traj), "range_km": round(proj.range_km(), 4), "flight_time_s": round(proj.flight_time(), 2), "max_altitude_m": round(proj.max_altitude_m(), 1), "impact": (traj[-1][0], traj[-1][1]) if traj else None, "traj_shape": list(proj.to_numpy().shape)} def _run_water_flow(self, lat, lon, params) -> Dict: from ..sims.flow import WaterFlow wf = WaterFlow(self._dem, patch_km=params.get("patch_km", 10)) path = wf.run(lat, lon, max_steps=params.get("steps", 5000)) return {"sim_type": "water_flow", "steps": len(path), "total_descent_m": round(wf.total_descent_m(), 1), "accumulation": wf.accumulation(), "sink": (path[-1][0], path[-1][1]) if path else None} def _run_agent(self, lat, lon, params) -> Dict: from ..sims.agent import TerrainAgent tlat = params.get("target_lat", lat + 0.05) tlon = params.get("target_lon", lon + 0.05) agent = TerrainAgent(self._dem, lat, lon, tlat, tlon, step_m=params.get("step_m", 300)) episode = agent.generate_episode( max_steps=params.get("steps", 300), policy=params.get("policy", "mixed"), ) arr = agent.to_numpy() return {"sim_type": "agent", "steps": len(episode), "reached_target": agent.reached_target(), "total_reward": round(sum(r["reward"] for r in episode), 2), "start": (lat, lon), "target": (tlat, tlon), "episode_shape": list(arr.shape) if arr.size else [0, 7]} def _run_traffic(self, lat, lon, params) -> Dict: if self._traffic is None: return {"error": "No TrafficRouter provided to Simu."} info = self._traffic.traffic_at(lat, lon) return {"sim_type": "traffic", **info.to_dict()} def _run_profile(self, lat, lon, params) -> Dict: tlat = params.get("target_lat", lat + 0.1) tlon = params.get("target_lon", lon + 0.1) steps = params.get("steps", 200) dists, elevs = self._dem.elevation_profile(lat, lon, tlat, tlon, steps=steps) return {"sim_type": "profile", "start": (lat, lon), "end": (tlat, tlon), "total_distance_km": round(float(dists[-1]), 3), "min_elev_m": round(float(elevs.min()), 1), "max_elev_m": round(float(elevs.max()), 1), "steps": steps} # ------------------------------------------------------------------ # Helpers # ------------------------------------------------------------------ def _print(self, msg: str): if self._verbose: print(msg, flush=True) def _summarise(self, output: Dict) -> str: if not output or "error" in output: return f"Error: {output.get('error', '?')}" if output else "no output" sim = output.get("sim_type", "?") if sim == "random_walk": return (f"walked {output['total_distance_km']} km, " f"gain {output['elevation_gain_m']} m") if sim == "projectile": return (f"range {output['range_km']} km, " f"flight {output['flight_time_s']} s, " f"peak {output['max_altitude_m']} m") if sim == "water_flow": return f"{output['steps']} steps, descent {output['total_descent_m']} m" if sim == "agent": flag = "✓ reached" if output["reached_target"] else "✗ missed" return (f"{output['steps']} steps, {flag} target, " f"reward {output['total_reward']}") if sim == "traffic": return (f"{output.get('speed_kmh','?'):.1f} km/h " f"[{output.get('congestion_level','?')}] " f"src={output.get('source','?')}") if sim == "profile": return (f"{output['total_distance_km']} km, " f"{output['min_elev_m']}–{output['max_elev_m']} m elev") return str(output) @property def brain_mode(self) -> Optional[str]: return self._brain_mode @property def sim_mode(self) -> Optional[str]: return self._sim_mode @property def model_loaded(self) -> bool: return self._model is not None # --------------------------------------------------------------------------- # CLI (`simu` command) # --------------------------------------------------------------------------- def _cli_main(): print("╔══════════════════════════════════════════════╗") print("║ Simu — MSKit AI Simulation Assistant 🤖 ║") print("║ Type 'help', 'switch brain', ║") print("║ 'switch sim', or 'quit' ║") print("╚══════════════════════════════════════════════╝\n") simu = Simu(verbose=True) # startup fires on first chat() while True: try: user_input = input("You: ").strip() except (EOFError, KeyboardInterrupt): print("\nSimu: Bye! 👋") break if not user_input: continue low = user_input.lower() if low in ("quit", "exit", "bye", "q"): print("Simu: Bye! 👋") break if low == "help": simu.help() continue if low in ("switch brain", "change brain", "change model"): simu.switch_brain() continue if low in ("switch sim", "switch simulation", "change sim", "change mode"): simu.switch_sim_mode() continue simu.chat(user_input)