v0.3.1: survival behaviour overhaul — storyline, biome-aware scout, wedge-relocate, food/perf fixes, monitor TUI (#28)
* docs(v0.3.1): PRD — LLM prompt cost optimization
Design-only commit; no runtime changes. Spec for the next patch iteration.
Goal: cut per-advise() input tokens from ~800 to ≤300, preserving the
LLM's ability to produce valid registered skill ids and useful rationale.
Five proposed changes ranked by impact:
P1 Compact registry format (saves ~350t/call) — group by namespace,
comma-list ids, drop human titles. Default mode for advisor;
verbose mode kept for postmortem/reflect.
P2 Need-scoped registry (~50t additional) — show LLM only skills
relevant to the active Maslow need + always-available safety
skills (survive.flee, pillar-up, recovery.tunnel-out, explore.*).
P3 Snapshot pruning (~50t) — drop weather/experience/dimension/biome/
players from the user prompt; the LLM doesn't consult them.
P4 Prompt caching probe — check if TimeWeb passes through
prompt_tokens_details.cached_tokens. If yes, restructure prefix
to maximize cache hits (cached input is ~10x cheaper at OpenAI).
P5 Per-trigger cost telemetry in scripts/list-improvements.js --stats:
avg_in / avg_out / cost_₽ / share% per trigger_reason, using
TIMEWEB_PRICE_IN_RUB_PER_M and TIMEWEB_PRICE_OUT_RUB_PER_M env.
Trigger: TimeWeb admin panel after first day of v0.3.0 live showed
34K tokens / day at low activity. At cap budget that projects to
~480₽/month (101₽/M in, 608₽/M out for gpt-5.4-mini). Manageable
but the savings are mostly free — repeated infra tokens, not signal.
All changes are additive; runtime behaviour stays the same. If the
LLM produces worse advice with the compact registry, flip back via a
single constant in fast-advisor.js.
Acceptance: re-run scripts/check-timeweb.js probe 3 — expect
tokens_in ≤ 300 (was ~800). Live for 1h, check --stats: avg_in ≤ 300
per trigger group. Existing 360 tests still green.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(v0.3.1): storyline — canonical Minecraft survival quest
The bot has been stuck in a loop for two days:
acquire-food (fail: no nearby food) → explore.far → pillar-up (fail) → repeat
Diagnosis: manifesto + LLM advisor both correctly identify "you need
food" but neither expresses *what concretely to do next*. Manifesto is
a priority ladder (need-detection), not a narrative arc.
This commit adds the missing narrative layer — an ordered list of
operational steps that mirror the vanilla Minecraft survival path:
1. orient_self — Понять где я
2. first_wood — Собрать 8 поленьев
3. crafting_basics — Сделать верстак и палки
4. first_tools — Деревянные орудия
5. first_food — Найти первую еду
6. shelter_minimal — Простой шелтер с кроватью
7. stone_tier — Каменные орудия
8. food_security — Запас еды на 16+
9. iron_age — Железо и печь
10. settle_base — Постоянная база
11. village_grow — Развивать деревню (ongoing)
Each step has:
- completed(snapshot) → bool — detects achievement from snapshot
- suggestSkill(snapshot) → { skillId, args? } — concrete next dispatch
- emergencyPause(snapshot) → bool — defers to manifesto L0 alive
emergencies (low HP near hostile, lava under foot, food = 0)
- narration_ru — chat-friendly Russian one-liner spoken on entry
Components:
- runtime/goal/storyline.js — 11-step canonical quest catalogue
- runtime/goal/state.js — pickCurrentStep(snapshot) walks the list,
returns first non-completed step + its suggestion. 3s cache.
Validates suggestSkill's skillId against the live registry.
- runtime/reflex.js — curriculumReflex dispatch priority is now:
1. manifesto (L0 alive emergencies always win)
2. storyline (concrete operational subgoal)
3. curriculum plan (legacy fallback)
Tests pass ctx.disableStoryline=true for isolation.
- runtime/bot.js — snapshot.storyStep populated each tick so
chatter/advisor/reflect observers see the same view.
- runtime/coach/fast-advisor.js — buildUserPrompt now embeds the
current step + its suggested skill, so LLM advice is anchored
("step 5 first_food, storyline wants survive.acquire-food, but
recent dispatches show it's failing — try explore.far + scout").
- runtime/coach/advisor-trigger.js — forwards ctx.storyStep into
advise() and logs step id at trigger time.
- runtime/coach/reflect.js — reflection prompt includes storyline
progress so 30-min self-assessment is anchored.
- runtime/persona/chatter.js — narrates step.narration_ru on
transition. Rate-limited via existing maybeNarrateRaw().
New operator CLI:
- scripts/show-story.js — fetches the live snapshot via IPC sock and
prints step progress with ✓/→/ markers, current skill, inventory.
Falls back to --plain catalogue view when bot offline.
Token cost impact: ~+30 input tokens per advise() call (one extra
line in user prompt). Trivial vs the value of grounding LLM advice
in a concrete narrative.
Operator usage:
node scripts/show-story.js # live progress + which step + why
node scripts/show-story.js --plain # static catalogue of all 11 steps
Tests: 376 green (was 360, +16 storyline tests).
Also in this branch (already committed): dev/v0.3.1/PRD.md —
LLM prompt cost optimization design doc.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(v0.3.1): storyline beats manifesto L1+ (only L0 alive emergencies override)
Found in live logs after the previous commit deployed:
storyline: step 1/11: orient_self → explore.wander
advisor-trigger: firing because wedged (planned=survive.acquire-food, ...)
Manifesto was still picking survive.acquire-food (L1 food) over the
storyline's orient_self → explore.wander. That's the wrong precedence —
storyline expresses a *concrete operational subgoal* and L1+ manifesto
needs are just "you'd benefit from food" priorities, not emergencies.
New dispatch precedence in curriculumReflex:
1. manifesto L0 (alive emergencies: lava, low-HP+hostile, food=0)
2. storyline (concrete narrative subgoal — beats L1+ manifesto)
3. manifesto L1+ (fallback when storyline has no concrete suggestion)
4. curriculum plan (legacy fallback)
This way the bot starts following the narrative arc even while
manifesto's L1 food is technically unsatisfied — orient_self runs to
completion before pursuing food explicitly. Storyline already handles
food as step 5 (first_food), so we're not skipping it.
Tests: 378 green (+2 priority-ordering tests):
- L0 manifesto emergency: upstream reflex (defend/modes) catches before
curriculum dispatch
- storyline beats manifesto when both have suggestions: well-fed bot
with logs → craft.planks (storyline crafting_basics), not gather.logs
(manifesto L2)
- updated "manifesto fallback" test to require disableStoryline=true
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(tui): fullscreen monitor-only TUI (opencode-style)
Replaces the old tui/tui.tsx hotkey-heavy dashboard with a read-only
observability screen. Operator actions live in scripts/* now —
TUI is for watching, not driving.
Layout (top to bottom, all auto-resizing to terminal):
1. Header — MC/IPC status, pos, HP, food, day/night, hostiles
2. Storyline — current step + 11-step quest map (✓/→/○)
3. Activity — last N skill dispatches (colour by outcome)
4. MC Chat — last N chat lines (cyan for bot, yellow for players)
5. Advisor — last N LLM recommendations (trigger + outcome + tokens)
6. Improvements — open requests from knowledge.improvement_requests
7. Footer — 24h token usage + cost in ₽ + q-to-quit
Data sources:
- IPC sock: snapshot frames, log frames, chat frames (push)
- SQLite knowledge.db: advisor_recommendations + improvement_requests
polled every 5s (pull)
Token cost displayed live using TIMEWEB_PRICE_IN_RUB_PER_M /
TIMEWEB_PRICE_OUT_RUB_PER_M env vars (defaults: 101 / 608 for
gpt-5.4-mini).
Switches:
- npm run tui → new monitor (this file)
- npm run tui:legacy → old action-driven tui/tui.tsx (kept for now)
Implementation notes:
- Uses ink + alternate-screen-buffer ANSI for proper "opencode-feel"
fullscreen behaviour; restores prior terminal contents on quit.
- Skips alt-screen and useInput when stdin/stdout isn't a TTY
(smoke tests, piped output) — both gracefully degrade.
- Stable React keys via per-event uid counter, avoids reconciler
duplicate-key warnings as logs/chat/dispatches stream in.
- Resize handled via 1s stdout-dimension poll, NOT direct
'resize' listener (which conflicts with ink's own listener and
triggers MaxListenersExceededWarning).
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* ui(tui): compact 4-section monitor (was 6) — fits 1080p without zoom
Operator reported the TUI overflowed the screen unless terminal was
zoomed way out. The 11-step storyline list alone was eating ~13
rows, and each advisor/improvement entry took 2-3 rows. Now:
- Header + storyline collapsed into one panel (2 lines):
line 1: pepa · ●MC ●IPC · 1m50s · pepa_bot · (697,61,702) · HP 20 · food 5 · ☀ · ⚔60(creeper@58b)
line 2: story ▓▒░░░░░░░░░ 1/11 orient_self · Понять где я → explore.wander
The 11-step ladder is now a unicode progress bar (▓ done, ▒ current,
░ pending) — same info, fits in one row.
- Advisor entries: one line each instead of two.
✓ wedged_60s → survive.flee 802t 1900ms
(outcome mark / trigger / target skill / tokens / latency)
- Improvements entries: one line each instead of two.
#1 P2 ×3 Add craft.iron-pickaxe skill
Description dropped from the row — use `node scripts/list-improvements.js`
for full text.
- Sections: 4 (was 6).
[header+story] · [activity | chat] · [advisor | improvements] · [footer]
Tested on a typical 1080p terminal — fits comfortably without zoom.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(v0.3.1): real survival patterns — biome-aware scout, wedge-relocate, escape-pit-safe
Operator reported the bot wandered the same 50×50 patch for 2 hours
without making any progress toward food. Diagnosis showed three root
causes; this commit addresses all five open improvement_requests
the LLM (postmortem + tuner) flagged automatically.
Research basis (`Voyager`, `Plan4MC`, `GITM`, `Mindcraft`):
- Coverage / commit-to-cardinal exploration when local scan fails
- Biome-aware strategy switching using a static affordance table
- Wedge detector above the skill layer that triggers RELOCATE not
RETRY (per-skill stuck checks reset on re-entry — useless)
- Time-in-region bbox heuristic + need-duration AND skill-cycle gate
Concrete changes:
1. `runtime/goal/storyline.js`
- orient_self.completed: added timeout fallback (HP=full + session
>120s → done) so barren biomes don't block the bot on step 1.
Closes improvement #2 'Нет навыка оценки когда сменить район'.
- first_food.suggestSkill: now picks survive.scout-food (new) when
no passive mob is nearby; falls back to survive.acquire-food only
when something is in immediate range.
2. `runtime/biome-affordances.js` (new)
- Static table: 40+ biomes → {has_passive_mobs, has_trees,
has_water, has_crops, livable}.
- Unknown biomes return optimistic defaults to avoid regressions.
- Closes improvement #1 'Нет навыка целевого поиска еды по биому'.
3. `runtime/skills/scout-food.js` (new — survive.scout-food)
- Tiered strategy: biome check → scan 32 → scan 64 → commit a
cardinal for 200 blocks rescanning every 16. On cardinal
exhaustion, returns code:"exhausted" so the curriculum can
escalate to village.relocate.
- In barren biomes (desert/ocean/snowy_plains) the scan is
SKIPPED — bot walks straight toward the nearest neighbour
biome that affords passive mobs (8-direction biome probe at
radius 64).
4. `runtime/awareness/wedge-detector.js` (new)
- Rolling 10-min position bbox tracker. observe() called every
tick; isWedged() returns true when bbox<50 AND active need
unmet >5min AND skill cycles ≥3.
- markRelocationStarted() suppresses further wedge firings
until the bot has displaced ≥200b — prevents stack overflow
of relocate calls.
- Lives ABOVE the skill layer (in runtime/reflex.js), because
any per-skill stuck check resets on re-entry.
5. `runtime/skills/relocate.js` (new — village.relocate)
- 300-block walk in least-recently-used cardinal (per-incident
memory in ctx.recentRelocations).
- Re-paths every 32 blocks, soft-tolerates pathfinder failures
(3 consecutive throws → exit with code:"stuck_in_place").
- Closes improvement #2 + #4 ('low success rate trigger').
6. `runtime/skills/escape-pit-safe.js` (new — recovery.escape-pit-safe)
- Surveys 4 cardinals AND ceiling height before committing.
Picks the direction with most open blocks (≥3, no lava).
Falls through to pillar-up only if ceiling clear ≥4b. Returns
code:"no_strategy" if both blocked so curriculum can escalate
to relocate.
- Closes improvement #3 'Нет навыка для безопасного выхода'.
7. `runtime/reflex.js`
- Wedge detector wired before manifesto/storyline. If wedge.wedged
is true, dispatches village.relocate directly and returns —
bypasses every other branch.
- ctx.disableWedge flag for tests.
8. `runtime/coach/advisor-trigger.js`
- LLM provider outage backoff: 3 consecutive http_400 / timeout /
network_error → suppress advisor for 10 min. Today's TimeWeb
gpt-5.4-mini was 400'ing for an hour straight; we were spending
trigger budget on dead calls. Closes improvement implicit gap
in #5.
9. `runtime/bot.js`
- Tracks botSpawnedAt; snapshot._sessionMs exposed for storyline
orient_self timeout fallback.
Tests: 396 green (was 378, +18):
- runtime/biome-affordances.test.js — 8 tests
- runtime/awareness/wedge-detector.test.js — 9 tests
- runtime/goal/storyline.test.js — 1 new test (orient_self timeout)
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(coach/trigger-tuner): crash after ~1h — runOnce is sync, not a Promise
The live bot died overnight with:
TypeError: runOnce(...).catch is not a function
at trigger-tuner.js:42 → [supervisor] child exited code=1
attach() wrapped the timer body as `runOnce().catch(...)` but
runOnce() returns a plain {ok, flagged, ...} object (pure SQL, no
await). The first tuner tick (60min after spawn) threw → killed the
whole bot process. Never surfaced before because the bot rarely ran
uninterrupted for a full hour during development.
Fix: guard the synchronous call with try/catch, matching how
persona/chatter.js already does its sync tick. (postmortem.drainOnce
and reflect.runOnce ARE async, so their .catch is correct — audited.)
Regression test added: captures the setInterval callback and invokes
it synchronously, asserting it does not throw.
Tests: 397 green.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(v0.3.1): mechanical food/stuck fixes — bot reaches the chicken now
The wedge wasn't only in the manifesto layer; several mechanical bugs
kept the bot in a dead random-walk:
- storyline / manifesto / curriculum: "local food" now means an edible
passive mob within <=32 blocks. A distant chicken or a cod no longer
fools the bot into dispatching acquire-food (which then fails on
no_path). Long-range food goes through scout-food instead.
- scout-food: partial approach to a target now counts as progress
(approached_target, e.g. moved:14); a blocked heading is NOT counted
as movement; added blind/tunnel fallback so it doesn't die when the
pathfinder can't route cleanly.
- acquire-food: on no_path it now also tries a blind/tunnel approach to
the animal; no_drop routes back into food scouting instead of giving
up.
- explore.far / relocate / flee: fewer false "done" results (micro-steps
no longer counted as success), more genuine escapes from stuck.
- scripts/show-story.js: live IPC now actually renders the current
storyline step.
Verification: scripts/lint-patch.js clean; npm test 404/404 green; bot
relaunched in tmux `pepa`. Live logs show real progress — bot switched
to survive.scout-food, approached the chicken (approached_target
moved:14), then reached survive.acquire-food: hunting chicken. Food
isn't fully closed yet but the remaining issue is concrete pickup/drop,
not dead random-walk.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(v0.3.1): sated bot stops chasing food + perf-leak + fuzzy improvement dedup
Third day of "bot just walks back and forth burning tokens". Root
causes were mechanical, not the manifesto:
1. SATED BOT CHASING FOOD (the big one)
Bot had food=17 (nearly full) but storyline first_food + manifesto
L1 required 2+ food ITEMS in inventory, so it looped scout-food /
acquire-food for hours instead of working. Now both treat a hunger
bar >= 14 (SATED_FOOD) as satisfied even with empty food inventory —
a full bot chops wood / makes tools and grabs food opportunistically,
only hard-pursuing food when actually hungry (< 14).
manifesto/needs.js foodDetect + goal/storyline.js first_food.completed.
2. perf_hooks MEMORY LEAK (overnight OOM suspect)
"MaxPerformanceEntryBufferExceededWarning: 1,000,001 measure entries".
mineflayer/pathfinder emit perf marks we never consume. Added a
60s reaper in bot.js (performance.clearMeasures/clearMarks). unref'd.
3. IMPROVEMENT QUEUE SELF-DUPLICATING
The LLM re-filed closed gaps with reworded titles (#5/#8/#9 were
dupes of implemented #1/#2/#3). Exact-title dedup missed them.
Replaced with token-set fuzzy match (isDuplicateTitle): jaccard>=0.75
OR >=3 shared meaningful tokens with jaccard>=0.5. Also: a re-filed
gap that's already implemented/rejected is NOT resurrected as a new
open row. Cleared all 5 open requests (now genuinely implemented).
Also confirmed (no change needed):
- canDig=true is a DELIBERATE codebase-wide choice ("without it the bot
gets permanently stuck", actions.js). The stale memory recommending
canDig=false is updated. ViaBackwards dig works partially (dug:1
moved:1.8 observed); false would trap the bot in every pit.
- scout-food already has blind/tunnel fallback + 12s step timeout
(operator's earlier edits) so trapped-pathfinder degrades instead of
hanging 30s.
Tests: 407 green (was 404). Updated needs/state/storyline tests for the
SATED_FOOD threshold; added fuzzy-dedup + tokenize/jaccard tests.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---------
Co-authored-by: Yuriy Mayatnikov <mayatnikov@me.com>
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
This commit was merged in pull request #28.
This commit is contained in:
Yuriy Mayatnikov
+487
@@ -0,0 +1,487 @@
|
||||
/**
|
||||
* pepa monitor — fullscreen, read-only TUI.
|
||||
*
|
||||
* Replaces the old action-heavy tui/tui.tsx with a pure observability
|
||||
* dashboard inspired by opencode's full-screen layout. No hotkeys to
|
||||
* dispatch skills / send chat / approve proposals — operator does that
|
||||
* via scripts/* or by writing to the IPC sock directly. This screen
|
||||
* just shows what the bot is doing, in colour.
|
||||
*
|
||||
* Panels (top → bottom):
|
||||
* 1. Header — connection / position / hp / food / time
|
||||
* 2. Storyline — current step + the 11-step quest map
|
||||
* 3. Activity — last N dispatches (colour-coded by outcome)
|
||||
* + MC chat — last N lines
|
||||
* 4. Advisor — last 6 LLM recommendations (trigger / outcome / tokens)
|
||||
* + Improvements — open queue from improvement_requests
|
||||
* 5. Footer — token usage today, advisor stats, q to quit
|
||||
*
|
||||
* Live data sources:
|
||||
* - IPC sock (snapshot frames, log frames, chat frames)
|
||||
* - SQLite (knowledge.db) polled every 5s for advisor + improvements
|
||||
*/
|
||||
|
||||
import React, { useEffect, useReducer, useState } from "react";
|
||||
import { render, Box, Text, useApp, useInput, useStdout } from "ink";
|
||||
import { createIpcClient } from "./ipc-client.js";
|
||||
import { EVENT_TYPES } from "../runtime/ipc-protocol.js";
|
||||
import { stateDir } from "../runtime/config.js";
|
||||
import { initKnowledge, isAvailable as knowledgeReady, recentRecommendations, listImprovements, recommendationStats } from "../runtime/knowledge/index.js";
|
||||
|
||||
// --- types ------------------------------------------------------------------
|
||||
|
||||
type LogEntry = { ts: string; level: string; source: string; text: string };
|
||||
type ChatEntry = { uid: number; ts: string; from: string; text: string; kind: string };
|
||||
type Snapshot = Record<string, any>;
|
||||
type Dispatch = { uid: number; ts: number; kind: "start" | "end"; label: string; ok?: boolean; code?: string; detail?: string };
|
||||
|
||||
let _uidSeq = 0;
|
||||
function nextUid() { _uidSeq += 1; return _uidSeq; }
|
||||
|
||||
type State = {
|
||||
connectedIpc: boolean;
|
||||
snapshot: Snapshot;
|
||||
logs: LogEntry[];
|
||||
chat: ChatEntry[];
|
||||
dispatches: Dispatch[];
|
||||
startedAt: number;
|
||||
};
|
||||
|
||||
type Action =
|
||||
| { type: "ipc-connected" }
|
||||
| { type: "ipc-disconnected" }
|
||||
| { type: "snapshot"; payload: Snapshot }
|
||||
| { type: "log"; payload: LogEntry }
|
||||
| { type: "chat"; payload: { from: string; text: string; kind: string }; ts: string };
|
||||
|
||||
const MAX_LOGS = 200;
|
||||
const MAX_CHAT = 50;
|
||||
const MAX_DISPATCHES = 30;
|
||||
|
||||
// --- reducer ----------------------------------------------------------------
|
||||
|
||||
function reducer(state: State, action: Action): State {
|
||||
switch (action.type) {
|
||||
case "ipc-connected":
|
||||
return { ...state, connectedIpc: true };
|
||||
case "ipc-disconnected":
|
||||
return { ...state, connectedIpc: false };
|
||||
case "snapshot":
|
||||
return { ...state, snapshot: action.payload };
|
||||
case "log": {
|
||||
const logs = [...state.logs, action.payload].slice(-MAX_LOGS);
|
||||
// also derive a dispatches view: lines like "→ label" or "← label ok/fail (...)"
|
||||
const dispatches = extractDispatch(state.dispatches, action.payload);
|
||||
return { ...state, logs, dispatches };
|
||||
}
|
||||
case "chat": {
|
||||
const chat = [...state.chat, { uid: nextUid(), ts: action.ts, ...action.payload }].slice(-MAX_CHAT);
|
||||
return { ...state, chat };
|
||||
}
|
||||
default:
|
||||
return state;
|
||||
}
|
||||
}
|
||||
|
||||
function extractDispatch(prev: Dispatch[], log: LogEntry): Dispatch[] {
|
||||
if (log.source !== "dispatch") return prev;
|
||||
const ts = Date.parse(log.ts) || Date.now();
|
||||
// "→ label" — skill starting
|
||||
const startMatch = /^→\s+(\S+)/.exec(log.text);
|
||||
if (startMatch) {
|
||||
return [...prev, { uid: nextUid(), ts, kind: "start", label: startMatch[1] }].slice(-MAX_DISPATCHES);
|
||||
}
|
||||
// "← label ok/fail (...)" — skill ending
|
||||
const endMatch = /^←\s+(\S+)\s+(ok|fail)(?:\s+\((.*)\))?/.exec(log.text);
|
||||
if (endMatch) {
|
||||
const [, label, outcome, detail] = endMatch;
|
||||
return [...prev, { uid: nextUid(), ts, kind: "end", label, ok: outcome === "ok", detail }].slice(-MAX_DISPATCHES);
|
||||
}
|
||||
return prev;
|
||||
}
|
||||
|
||||
// --- helpers ----------------------------------------------------------------
|
||||
|
||||
function formatAge(ts: number) {
|
||||
const dt = Math.max(0, Date.now() - ts);
|
||||
if (dt < 60_000) return `${Math.floor(dt / 1000)}s`;
|
||||
if (dt < 3600_000) return `${Math.floor(dt / 60_000)}m`;
|
||||
const h = Math.floor(dt / 3600_000);
|
||||
const m = Math.floor((dt % 3600_000) / 60_000);
|
||||
return `${h}h${m}m`;
|
||||
}
|
||||
|
||||
function formatDuration(ms: number) {
|
||||
const s = Math.floor(ms / 1000) % 60;
|
||||
const m = Math.floor(ms / 60_000) % 60;
|
||||
const h = Math.floor(ms / 3600_000);
|
||||
if (h > 0) return `${h}h${m.toString().padStart(2, "0")}m`;
|
||||
if (m > 0) return `${m}m${s.toString().padStart(2, "0")}s`;
|
||||
return `${s}s`;
|
||||
}
|
||||
|
||||
function shortTime(ts: number) {
|
||||
const d = new Date(ts);
|
||||
return `${d.getHours().toString().padStart(2, "0")}:${d.getMinutes().toString().padStart(2, "0")}:${d.getSeconds().toString().padStart(2, "0")}`;
|
||||
}
|
||||
|
||||
function hpColor(hp: number | undefined) {
|
||||
if (hp == null) return "gray";
|
||||
if (hp <= 5) return "red";
|
||||
if (hp <= 12) return "yellow";
|
||||
return "green";
|
||||
}
|
||||
function foodColor(food: number | undefined) {
|
||||
if (food == null) return "gray";
|
||||
if (food <= 4) return "red";
|
||||
if (food <= 10) return "yellow";
|
||||
return "green";
|
||||
}
|
||||
|
||||
// --- components -------------------------------------------------------------
|
||||
|
||||
function StatusHeader({ snapshot, connectedIpc, width, startedAt }: { snapshot: Snapshot; connectedIpc: boolean; width: number; startedAt: number }) {
|
||||
const pos = snapshot.position
|
||||
? `(${Math.round(snapshot.position.x)},${Math.round(snapshot.position.y)},${Math.round(snapshot.position.z)})`
|
||||
: "?";
|
||||
const hp = snapshot.health;
|
||||
const food = snapshot.food;
|
||||
const day = snapshot.isDay ? "☀" : "🌙";
|
||||
const session = formatDuration(Date.now() - startedAt);
|
||||
const mcOnline = snapshot.connected;
|
||||
const story = snapshot.storyStep;
|
||||
const idx = story?.index ?? 0;
|
||||
const cur = story?.step;
|
||||
const want = story?.suggestion?.skillId;
|
||||
// 11-step progress bar in 11 cells
|
||||
const bar = Array.from({ length: 11 }, (_, i) => {
|
||||
if (i < idx) return "▓";
|
||||
if (i === idx) return "▒";
|
||||
return "░";
|
||||
}).join("");
|
||||
return (
|
||||
<Box flexDirection="column" borderStyle="round" borderColor="cyan" paddingX={1} width={width}>
|
||||
<Box>
|
||||
<Text bold color="cyan">pepa</Text>
|
||||
<Text dimColor> · </Text>
|
||||
<Text color={mcOnline ? "green" : "red"}>{mcOnline ? "●MC" : "○MC"}</Text>
|
||||
<Text dimColor> · </Text>
|
||||
<Text color={connectedIpc ? "green" : "red"}>{connectedIpc ? "●IPC" : "○IPC"}</Text>
|
||||
<Text dimColor> · </Text>
|
||||
<Text>{session}</Text>
|
||||
<Text dimColor> · </Text>
|
||||
<Text bold>{snapshot.username ?? "?"}</Text>
|
||||
<Text dimColor> · </Text>
|
||||
<Text>{pos}</Text>
|
||||
<Text dimColor> · </Text>
|
||||
<Text>HP </Text><Text bold color={hpColor(hp)}>{hp ?? "?"}</Text>
|
||||
<Text dimColor> · </Text>
|
||||
<Text>food </Text><Text bold color={foodColor(food)}>{food ?? "?"}</Text>
|
||||
<Text dimColor> · </Text>
|
||||
<Text>{day}</Text>
|
||||
{(snapshot.hostileCount ?? 0) > 0 ? (
|
||||
<>
|
||||
<Text dimColor> · </Text>
|
||||
<Text color="red">⚔{snapshot.hostileCount}</Text>
|
||||
{snapshot.closestHostile ? <Text color="red">({snapshot.closestHostile.name}@{Math.round(snapshot.closestHostile.distance)}b)</Text> : null}
|
||||
</>
|
||||
) : null}
|
||||
</Box>
|
||||
<Box>
|
||||
<Text color="magenta">story </Text>
|
||||
<Text bold>{bar}</Text>
|
||||
<Text dimColor> </Text>
|
||||
<Text bold>{idx + 1}/11</Text>
|
||||
<Text dimColor> </Text>
|
||||
{cur ? (
|
||||
<>
|
||||
<Text color="white" bold>{cur.id}</Text>
|
||||
<Text dimColor> · </Text>
|
||||
<Text>{cur.title}</Text>
|
||||
</>
|
||||
) : <Text dimColor>(no story)</Text>}
|
||||
{want ? (
|
||||
<>
|
||||
<Text dimColor> → </Text>
|
||||
<Text color="cyan">{want}</Text>
|
||||
</>
|
||||
) : null}
|
||||
{story?.emergency ? <Text color="red" bold> [EMERGENCY]</Text> : null}
|
||||
</Box>
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
function ActivityPanel({ dispatches, width, height }: { dispatches: Dispatch[]; width: number; height: number }) {
|
||||
const visible = dispatches.slice(-height);
|
||||
return (
|
||||
<Box flexDirection="column" borderStyle="round" borderColor="blue" paddingX={1} width={width}>
|
||||
<Text bold color="blue">Activity (last {visible.length})</Text>
|
||||
{visible.map((d) => {
|
||||
if (d.kind === "start") {
|
||||
return (
|
||||
<Text key={d.uid} dimColor>
|
||||
{shortTime(d.ts)} → <Text color="white">{d.label}</Text>
|
||||
</Text>
|
||||
);
|
||||
}
|
||||
const color = d.ok ? "green" : "red";
|
||||
const tail = d.detail ? ` (${String(d.detail).slice(0, 30)})` : "";
|
||||
return (
|
||||
<Text key={d.uid}>
|
||||
<Text dimColor>{shortTime(d.ts)} </Text>
|
||||
<Text color={color}>← {d.label} {d.ok ? "ok" : "fail"}</Text>
|
||||
<Text dimColor>{tail}</Text>
|
||||
</Text>
|
||||
);
|
||||
})}
|
||||
{visible.length === 0 ? <Text dimColor>(waiting for activity…)</Text> : null}
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
function ChatPanel({ chat, width, height }: { chat: ChatEntry[]; width: number; height: number }) {
|
||||
const visible = chat.slice(-height);
|
||||
return (
|
||||
<Box flexDirection="column" borderStyle="round" borderColor="green" paddingX={1} width={width}>
|
||||
<Text bold color="green">MC Chat (last {visible.length})</Text>
|
||||
{visible.map((c) => (
|
||||
<Text key={c.uid}>
|
||||
<Text dimColor>{c.ts?.slice(11, 16) ?? ""} </Text>
|
||||
<Text color={c.kind === "system" ? "gray" : c.from === "pepa_bot" ? "cyan" : "yellow"} bold={c.from !== "pepa_bot" && c.kind !== "system"}>
|
||||
{c.from}:
|
||||
</Text>
|
||||
<Text> {c.text.slice(0, width - 12)}</Text>
|
||||
</Text>
|
||||
))}
|
||||
{visible.length === 0 ? <Text dimColor>(no chat yet…)</Text> : null}
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
function AdvisorPanel({ recs, width, height }: { recs: any[]; width: number; height: number }) {
|
||||
const visible = recs.slice(0, height);
|
||||
return (
|
||||
<Box flexDirection="column" borderStyle="round" borderColor="yellow" paddingX={1} width={width}>
|
||||
<Text bold color="yellow">Advisor (last {visible.length})</Text>
|
||||
{visible.map((r) => {
|
||||
const ok = r.outcome_ok;
|
||||
const outcomeMark = ok == null ? "·" : ok ? "✓" : "✗";
|
||||
const outcomeColor = ok == null ? "gray" : ok ? "green" : "red";
|
||||
const target = r.recommended_skill ?? r.action;
|
||||
const trigger = String(r.trigger_reason ?? "?");
|
||||
// One line per recommendation: " ✓ wedged_60s → survive.flee 802t 1900ms"
|
||||
const lhs = `${outcomeMark} ${trigger} → ${target}`;
|
||||
const rhs = `${r.tokens_in ?? "?"}t ${r.latency_ms ?? "?"}ms`;
|
||||
const free = Math.max(20, width - rhs.length - 6);
|
||||
return (
|
||||
<Text key={`adv-${r.id}`}>
|
||||
<Text color={outcomeColor} bold>{outcomeMark} </Text>
|
||||
<Text color="white">{trigger}</Text>
|
||||
<Text dimColor> → </Text>
|
||||
<Text color="cyan">{String(target).slice(0, Math.max(8, free - trigger.length - 6))}</Text>
|
||||
<Text dimColor> {rhs}</Text>
|
||||
</Text>
|
||||
);
|
||||
})}
|
||||
{visible.length === 0 ? <Text dimColor>(no advisor calls yet)</Text> : null}
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
function ImprovementsPanel({ items, width, height }: { items: any[]; width: number; height: number }) {
|
||||
const visible = items.slice(0, height);
|
||||
return (
|
||||
<Box flexDirection="column" borderStyle="round" borderColor="magenta" paddingX={1} width={width}>
|
||||
<Text bold color="magenta">Improvements (open {items.length})</Text>
|
||||
{visible.map((r) => (
|
||||
<Text key={`imp-${r.id}`}>
|
||||
<Text color="gray">#{r.id} </Text>
|
||||
<Text color="yellow">P{r.priority}</Text>
|
||||
<Text dimColor> ×{r.votes} </Text>
|
||||
<Text color="white">{String(r.title).slice(0, Math.max(20, width - 14))}</Text>
|
||||
</Text>
|
||||
))}
|
||||
{visible.length === 0 ? <Text dimColor>(no improvement requests yet)</Text> : null}
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
function Footer({ stats, width }: { stats: any[]; width: number }) {
|
||||
const total = stats.reduce(
|
||||
(acc, s) => ({
|
||||
calls: acc.calls + (s.total ?? 0),
|
||||
succ: acc.succ + (s.succeeded ?? 0),
|
||||
fail: acc.fail + (s.failed ?? 0),
|
||||
in: acc.in + (s.avg_in ?? 0) * (s.total ?? 0),
|
||||
out: acc.out + (s.avg_out ?? 0) * (s.total ?? 0),
|
||||
}),
|
||||
{ calls: 0, succ: 0, fail: 0, in: 0, out: 0 },
|
||||
);
|
||||
const priceInRub = Number(process.env.TIMEWEB_PRICE_IN_RUB_PER_M) || 101;
|
||||
const priceOutRub = Number(process.env.TIMEWEB_PRICE_OUT_RUB_PER_M) || 608;
|
||||
const costRub = (total.in * priceInRub + total.out * priceOutRub) / 1_000_000;
|
||||
return (
|
||||
<Box flexDirection="column" borderStyle="round" borderColor="gray" paddingX={1} width={width}>
|
||||
<Box>
|
||||
<Text dimColor>Last 24h: </Text>
|
||||
<Text bold>{total.calls}</Text>
|
||||
<Text dimColor> advisor calls (</Text>
|
||||
<Text color="green">{total.succ} ok</Text>
|
||||
<Text dimColor> / </Text>
|
||||
<Text color="red">{total.fail} fail</Text>
|
||||
<Text dimColor>) tokens </Text>
|
||||
<Text bold>{Math.round(total.in / 1000)}K</Text>
|
||||
<Text dimColor> in / </Text>
|
||||
<Text bold>{Math.round(total.out / 1000)}K</Text>
|
||||
<Text dimColor> out ≈ </Text>
|
||||
<Text bold color="cyan">{costRub.toFixed(2)} ₽</Text>
|
||||
</Box>
|
||||
<Box>
|
||||
<Text dimColor>q — quit (bot keeps running)</Text>
|
||||
</Box>
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
// --- main app ---------------------------------------------------------------
|
||||
|
||||
function App() {
|
||||
const { exit } = useApp();
|
||||
const { stdout } = useStdout();
|
||||
// Sample stdout dimensions periodically. Subscribing directly to
|
||||
// stdout.on('resize') from a React hook conflicts with ink's own
|
||||
// listener and produces "MaxListenersExceededWarning" / reconciler
|
||||
// errors. A 1s poll is cheap and good enough — terminals don't
|
||||
// resize often.
|
||||
const [cols, setCols] = useState<number>((stdout as any)?.columns ?? 120);
|
||||
const [rows, setRows] = useState<number>((stdout as any)?.rows ?? 30);
|
||||
useEffect(() => {
|
||||
const t = setInterval(() => {
|
||||
setCols((stdout as any)?.columns ?? 120);
|
||||
setRows((stdout as any)?.rows ?? 30);
|
||||
}, 1000);
|
||||
return () => clearInterval(t);
|
||||
}, [stdout]);
|
||||
|
||||
const [state, dispatch] = useReducer(reducer, {
|
||||
connectedIpc: false,
|
||||
snapshot: {},
|
||||
logs: [],
|
||||
chat: [],
|
||||
dispatches: [],
|
||||
startedAt: Date.now(),
|
||||
});
|
||||
|
||||
const [client] = useState(() => createIpcClient());
|
||||
const [knowledgeOk, setKnowledgeOk] = useState(false);
|
||||
const [recs, setRecs] = useState<any[]>([]);
|
||||
const [improvements, setImprovements] = useState<any[]>([]);
|
||||
const [stats, setStats] = useState<any[]>([]);
|
||||
|
||||
// IPC
|
||||
useEffect(() => {
|
||||
const onConnected = () => dispatch({ type: "ipc-connected" });
|
||||
const onDisconnected = () => dispatch({ type: "ipc-disconnected" });
|
||||
const onFrame = (frame: any) => {
|
||||
switch (frame.type) {
|
||||
case EVENT_TYPES.STATUS: dispatch({ type: "snapshot", payload: frame.payload }); break;
|
||||
case EVENT_TYPES.LOG: dispatch({ type: "log", payload: frame.payload }); break;
|
||||
case EVENT_TYPES.CHAT: dispatch({ type: "chat", payload: frame.payload, ts: frame.ts }); break;
|
||||
case EVENT_TYPES.HELLO:
|
||||
if (frame.payload?.snapshot) dispatch({ type: "snapshot", payload: frame.payload.snapshot });
|
||||
if (frame.payload?.recentLogs) {
|
||||
for (const lg of frame.payload.recentLogs) dispatch({ type: "log", payload: lg });
|
||||
}
|
||||
break;
|
||||
}
|
||||
};
|
||||
(client as any).on("connected", onConnected);
|
||||
(client as any).on("disconnected", onDisconnected);
|
||||
(client as any).on("frame", onFrame);
|
||||
return () => {
|
||||
(client as any).off("connected", onConnected);
|
||||
(client as any).off("disconnected", onDisconnected);
|
||||
(client as any).off("frame", onFrame);
|
||||
client.close();
|
||||
};
|
||||
}, [client]);
|
||||
|
||||
// Knowledge DB init + polling
|
||||
useEffect(() => {
|
||||
let mounted = true;
|
||||
(async () => {
|
||||
try {
|
||||
await initKnowledge({ stateDir });
|
||||
if (!mounted) return;
|
||||
setKnowledgeOk(knowledgeReady());
|
||||
} catch {}
|
||||
})();
|
||||
const poll = () => {
|
||||
if (!knowledgeReady()) return;
|
||||
try {
|
||||
setRecs(recentRecommendations({ limit: 12 }));
|
||||
setImprovements(listImprovements({ status: "open", limit: 12 }));
|
||||
setStats(recommendationStats({ sinceHours: 24 }));
|
||||
} catch {}
|
||||
};
|
||||
poll();
|
||||
const t = setInterval(poll, 5000);
|
||||
return () => { mounted = false; clearInterval(t); };
|
||||
}, [knowledgeOk]);
|
||||
|
||||
// useInput requires TTY raw mode; skip it when stdin isn't a TTY
|
||||
// (e.g. when piped during a smoke test). Real `npm run tui` is always TTY.
|
||||
const isTty = !!process.stdin.isTTY;
|
||||
if (isTty) {
|
||||
// eslint-disable-next-line react-hooks/rules-of-hooks
|
||||
useInput((input, key) => {
|
||||
if (input === "q" || (key.ctrl && input === "c") || key.escape) {
|
||||
client.close();
|
||||
exit();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Layout math: compact 4-section vertical stack.
|
||||
// row budget:
|
||||
// header (story + status) ≈ 4 rows
|
||||
// middle activity/chat ≈ floor((rows - 4 - 4 - 4) / 2)
|
||||
// bottom advisor/improvements ≈ same
|
||||
// footer ≈ 4 rows
|
||||
const totalWidth = Math.max(80, cols);
|
||||
const halfWidth = Math.floor(totalWidth / 2);
|
||||
const totalRows = Math.max(20, rows);
|
||||
const middleRows = Math.max(5, Math.floor((totalRows - 4 - 4 - 4) / 2));
|
||||
|
||||
return (
|
||||
<Box flexDirection="column" width={totalWidth}>
|
||||
<StatusHeader snapshot={state.snapshot} connectedIpc={state.connectedIpc} width={totalWidth} startedAt={state.startedAt} />
|
||||
<Box flexDirection="row" width={totalWidth}>
|
||||
<ActivityPanel dispatches={state.dispatches} width={halfWidth} height={middleRows} />
|
||||
<ChatPanel chat={state.chat} width={totalWidth - halfWidth} height={middleRows} />
|
||||
</Box>
|
||||
<Box flexDirection="row" width={totalWidth}>
|
||||
<AdvisorPanel recs={recs} width={halfWidth} height={middleRows} />
|
||||
<ImprovementsPanel items={improvements} width={totalWidth - halfWidth} height={middleRows} />
|
||||
</Box>
|
||||
<Footer stats={stats} width={totalWidth} />
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
// --- entrypoint -------------------------------------------------------------
|
||||
|
||||
// Use the alternate screen buffer so the dashboard owns the entire viewport
|
||||
// and the operator's prior terminal contents come back after quit.
|
||||
// Skip when stdout isn't a TTY (e.g. piped output during smoke tests).
|
||||
const useAltScreen = !!process.stdout.isTTY && process.env.PEPA_TUI_NO_ALT !== "1";
|
||||
if (useAltScreen) {
|
||||
process.stdout.write("\x1b[?1049h\x1b[2J\x1b[H");
|
||||
const onExit = () => process.stdout.write("\x1b[?1049l");
|
||||
process.on("exit", onExit);
|
||||
process.on("SIGINT", () => { onExit(); process.exit(0); });
|
||||
process.on("SIGTERM", () => { onExit(); process.exit(0); });
|
||||
}
|
||||
|
||||
render(<App />);
|
||||
Reference in New Issue
Block a user