dexterm-cli 0.1.5 → 0.1.7

package/dist/packages/cli/src/screens/analyst-session.js

@@ -2,6 +2,7 @@
 // screen and the token ANALYST panel. Cyberspace styling: the verdict and the tool-call lines are
 // coral, the answer decrypts in through code glyphs, and a cost/latency footer sits on the caption.
 import { Canvas, badge, spinnerGlyph, decryptText, wrap, mix, fmtUsd, fmtPrice, fmtPctDir, } from '../../../tui/src/index.js';
+import { drawLarpGauge } from "../analyst/larp-gauge.js";
 const verdictColor = (c, v) => {
     const t = c.theme;
     if (v === 'WATCH')
@@ -19,7 +20,7 @@ export function renderAnalystSession(c, x, y, w, h, s, opts) {
     // Narrow panels (token screen) drop the model so cost · latency · tools still fits beside the title.
     const full = s.status === 'error' ? 'analyst unavailable' : s.footer;
     // 0.1.5: a codex conversation says so in the title; claude panels keep the original default.
-    const title = opts.title ?? (s.engine === 'codex' ? '✦ ANALYST · codex' : '✦ ANALYST · claude');
+    const title = opts.title ?? (s.engine === 'codex' ? '✦ ANALYST · codex' : s.engine === 'ollama' ? '✦ ANALYST · ollama' : '✦ ANALYST · claude');
     const caption = title.length + full.length + 10 <= w ? full : full.split(' · ').slice(0, 3).join(' · ');
     const capFg = s.status === 'error' ? t.warn : t.dim;
     const box = c.box(x, y, w, h, { title, titleFg: t.ai, caption, captionFg: capFg, border: bc });
@@ -126,6 +127,9 @@ export function renderAnalystSession(c, x, y, w, h, s, opts) {
             c.textR(box.x + 1, cy, inner - 1, right, { fg: t.muted, bg: mix(bg, vc, 0.18) });
         cy += 1;
     }
+    // task-1471: the LARP score gauge (from the MCP larp_check result, not the model), under the verdict.
+    if (s.larpGauge && cy < inputY - 1)
+        cy = drawLarpGauge(c, box.x + 2, cy, inner - 2, inputY - 1, s.larpGauge, bg);
     // task-1313 trading view: the directional bias + setup quality, drawn under the risk verdict.
     if (s.bias && cy < inputY - 1) {
         const bc2 = s.bias === 'long' ? t.up : s.bias === 'short' || s.bias === 'avoid' ? t.down : t.warn;
@@ -179,7 +183,7 @@ export function renderAnalystSession(c, x, y, w, h, s, opts) {
     // mcap/age + the analyst's one-line reason), navigable with ↑↓ and ⏎-to-jump. The numbers come from
     // live data (resolved by the caller from the app's data layer, never from the model's text).
     if (opts.results?.length && cy < inputY - 1) {
-        cy = renderResultsTable(c, box, bg, cy, inputY, inner, opts.results, opts.resultsCursor ?? 0, opts.resultsActive ?? false);
+        cy = renderResultsTable(c, box, bg, cy, inputY, inner, opts.results, opts.resultsCursor ?? 0, opts.resultsActive ?? false, opts.priceMode !== 'price');
     }
     if (s.candidates.length && cy < inputY - 1) {
         cy += 1;
@@ -247,14 +251,17 @@ function fmtAge(min) {
  * so it stays legible instead of wrapping into prose. The highlighted row (cursor) is tinted; when the
  * table is active a `▸` marks it and the footer hint changes. Returns the new y.
  */
-function renderResultsTable(c, box, bg, startY, inputY, inner, rows, cursor, active) {
+function renderResultsTable(c, box, bg, startY, inputY, inner, rows, cursor, active, mcapFirst = true) {
     const t = c.theme;
     let cy = startY + 1;
     if (cy >= inputY - 1)
         return cy;
     // Column plan: [symbol, price, 24h, liq, vol, mcap, age] then the reason fills the rest. Drop from
     // the right as width shrinks so a narrow panel still shows symbol + price + change + a reason.
-    const full = [['SYMBOL', 10], ['PRICE', 9], ['24H', 8], ['LIQ', 8], ['VOL', 8], ['MCAP', 8], ['AGE', 5]];
+    // task-1537: in the market-cap basis MCAP takes PRICE's slot (the headline number) and PRICE moves to MCAP's
+    const full = mcapFirst
+        ? [['SYMBOL', 10], ['MCAP', 9], ['24H', 8], ['LIQ', 8], ['VOL', 8], ['PRICE', 8], ['AGE', 5]]
+        : [['SYMBOL', 10], ['PRICE', 9], ['24H', 8], ['LIQ', 8], ['VOL', 8], ['MCAP', 8], ['AGE', 5]];
     let cols = full.slice();
     // keep trimming trailing columns until the header + a minimal reason (12) fits
     while (cols.length > 3 && cols.reduce((a, [, w]) => a + w + 1, 0) + 12 > inner - 2)

package/dist/packages/cli/src/screens/analyst.js

@@ -6,6 +6,7 @@ import { Canvas, sparkline, heatPct, decryptText, spinnerGlyph, fmtUsd, fmtPrice
 import { headerModel } from "../state.js";
 import { screenerView } from "../screener/view.js";
 import { renderAnalystSession } from "./analyst-session.js";
+import { priceModeOf } from "../display.js";
 import { resolveAnalystResults } from "../analyst/results.js";
 export function renderAnalyst(c, state) {
     const t = c.theme;
@@ -28,7 +29,7 @@ export function renderAnalyst(c, state) {
             frame: state.vfx.frame, code: state.vfx.code, calm: isCalm(state.vfx),
             input: state.aiInput ?? '', inputFocused: focused,
             scroll: state.aiScroll, revealAll: state.aiRevealAll,
-            results, resultsCursor: state.analyst.resultsCursor, resultsActive,
+            results, resultsCursor: state.analyst.resultsCursor, resultsActive, priceMode: priceModeOf(state), // task-1537
             inputHint: focused ? 'type your question…  ⏎ send · esc blur · analysis not advice'
                 : results.length ? 'i ask · ↑↓ pick coin · ⏎ open · o ticket · esc back'
                     : 'i ask · ⏎ focus · ↑↓ pick coin · PgUp/Dn scroll',
@@ -43,7 +44,7 @@ export function renderAnalyst(c, state) {
     if (state.screener.source !== 'fixtures') {
         const live = state.aiFocused === true;
         const eng = state.analystEngine ?? 'claude'; // 0.1.5: the user's own CLI that will answer (claude | codex)
-        const b = c.box(0, top, chatW, bottom - top, { title: `✦ ANALYST · ${eng}`, titleFg: t.ai, caption: `read-only · local ${eng} CLI · on demand`, captionFg: t.dim, border: bc });
+        const b = c.box(0, top, chatW, bottom - top, { title: `✦ ANALYST · ${eng}`, titleFg: t.ai, caption: `read-only · local ${eng === 'ollama' ? 'ollama model' : `${eng} CLI`} · on demand`, captionFg: t.dim, border: bc });
         const bbg = b.bg;
         const bin = b.w - 2;
         let by = b.y + 1;

package/dist/packages/cli/src/screens/autotrade-keys.js

@@ -0,0 +1,169 @@
+// dexterm — the AUTOTRADE screen's key handling (`Q`, task-1508). The loop calls autotradeKey() first while the
+// screen captures typed keys (an id / file line, a field value, the flatten confirm), and autotradeAction() for
+// every resolved action while the screen is open. Both only change this screen's state and the user's own
+// strategy files; nothing here reaches a wallet, a key, a mandate or the signer.
+import { INPUT_MAX, backtestSubject, beginFieldEdit, beginImport, beginNew, commitInput, commitTyping, confirmKey, exportSelected, nextView, openEditor, reloadList, refreshRunner, revalidateTyping, runnerVerb, saveEditor, selectedEntry, startBacktest, startCompareBacktest, startSweep, toggleMark, undoEditor, } from "./autotrade-ui.js";
+import { openReview, reviewKey } from "./autotrade-proposals.js";
+const PRINTABLE = (k) => (k.name === 'space' ? ' ' : k.name === 'char' && k.ch && !k.ctrl && !k.alt && !/[\u0000-\u001f\u007f]/.test(k.ch) ? k.ch : null);
+/** A captured key (input line, field value or confirm). Returns true when the key was consumed. */
+export function autotradeKey(ui, key) {
+    // task-1507: a chat proposal's review card owns the keyboard (y applies, a LOOSER edit needs a second y, n dismisses)
+    if (ui.review) {
+        ui.notice = reviewKey(ui, key);
+        if (!ui.review)
+            reloadList(ui);
+        return true;
+    }
+    if (ui.confirm) {
+        ui.notice = confirmKey(ui, key.name === 'char' && key.ch === 'y' && !key.ctrl && !key.alt);
+        return true;
+    }
+    if (ui.input) {
+        const inp = ui.input;
+        if (key.name === 'esc') {
+            ui.input = null;
+            ui.notice = null;
+            return true;
+        }
+        if (key.name === 'enter') {
+            ui.notice = commitInput(ui);
+            return true;
+        }
+        if (key.name === 'backspace') {
+            inp.text = inp.text.slice(0, -1);
+            return true;
+        }
+        if (key.ctrl && key.ch === 'u') {
+            inp.text = '';
+            return true;
+        }
+        const ch = PRINTABLE(key);
+        // an id is lowercase letters, digits and dashes only, so it can never carry a path
+        if (ch && (inp.kind === 'import' ? inp.text.length < INPUT_MAX : /^[a-z0-9-]$/.test(ch) && inp.text.length < 32))
+            inp.text += ch;
+        return true;
+    }
+    const ty = ui.view === 'editor' ? ui.editor?.typing : null;
+    if (ty) {
+        if (key.name === 'esc') {
+            ui.editor.typing = null;
+            ui.notice = null;
+            return true;
+        }
+        if (key.name === 'enter') {
+            ui.notice = commitTyping(ui);
+            return true;
+        }
+        if (key.name === 'backspace')
+            ty.text = ty.text.slice(0, -1);
+        else if (key.ctrl && key.ch === 'u')
+            ty.text = '';
+        else {
+            const ch = PRINTABLE(key);
+            if (ch && ty.text.length < INPUT_MAX)
+                ty.text += ch;
+            else
+                return true;
+        }
+        revalidateTyping(ui);
+        return true;
+    }
+    return false;
+}
+function move(ui, delta) {
+    if (ui.view === 'list')
+        ui.selected = Math.max(0, Math.min(ui.entries.length - 1, ui.selected + delta));
+    else if (ui.view === 'editor' && ui.editor)
+        ui.editor.selected = Math.max(0, Math.min(ui.editor.fields.length - 1, ui.editor.selected + delta));
+    else if (ui.view === 'compare' && ui.compare)
+        ui.compare.scroll = Math.max(0, ui.compare.scroll + delta);
+}
+const PAGE = 10;
+/**
+ * One resolved action on the AUTOTRADE screen. Returns true when it was handled here (the loop then does
+ * nothing else with it); false lets the loop's own handling run (esc on the list pops the screen stack, `q`
+ * quits, the global screen keys still navigate away).
+ */
+export function autotradeAction(ui, action) {
+    const say = (s) => { ui.notice = s ?? null; return true; };
+    const e = selectedEntry(ui);
+    switch (action) {
+        case 'move.down':
+            move(ui, 1);
+            return true;
+        case 'move.up':
+            move(ui, -1);
+            return true;
+        case 'move.pagedown':
+            move(ui, PAGE);
+            return true;
+        case 'move.pageup':
+            move(ui, -PAGE);
+            return true;
+        case 'move.top':
+            move(ui, -1e9);
+            return true;
+        case 'move.bottom':
+            move(ui, 1e9);
+            return true;
+        case 'back':
+            if (ui.view === 'list')
+                return false;
+            ui.view = 'list';
+            return say(null);
+        case 'autotrade.view':
+            nextView(ui);
+            if (ui.view === 'runner')
+                refreshRunner(ui);
+            return say(null);
+        case 'open':
+        case 'autotrade.edit':
+            if (ui.view === 'editor')
+                return say(beginFieldEdit(ui));
+            if (ui.view !== 'list')
+                return action === 'open' ? true : say('e edits from the strategies list');
+            return say(e ? openEditor(ui, e.id) : 'no strategy selected');
+        case 'autotrade.new': return say(ui.view === 'list' ? beginNew(ui, false) : 'n works on the strategies list (esc)');
+        case 'autotrade.dup': return say(ui.view === 'list' ? beginNew(ui, true) : 'd works on the strategies list (esc)');
+        case 'autotrade.import':
+            if (ui.view !== 'list')
+                return say('i works on the strategies list (esc)');
+            beginImport(ui);
+            return say(null);
+        case 'autotrade.export': return say(ui.view === 'list' ? exportSelected(ui) : 'x works on the strategies list (esc)');
+        case 'autotrade.compare': return say(ui.view === 'list' ? toggleMark(ui) : 'c marks strategies on the list (esc)');
+        case 'autotrade.save': return say(ui.view === 'editor' ? saveEditor(ui) : 's saves in the editor');
+        case 'autotrade.undo': return say(ui.view === 'editor' ? undoEditor(ui) : 'u undoes in the editor');
+        case 'autotrade.backtest': {
+            if (ui.view === 'compare')
+                return say(startCompareBacktest(ui));
+            if (ui.view === 'editor' && ui.editor)
+                return say(`${startBacktest(ui, ui.editor.id)}${ui.editor.edits.length ? ' (the saved version; s saves your edits first)' : ''}`);
+            if (ui.view === 'backtest') {
+                const s = backtestSubject(ui);
+                return say(s ? startBacktest(ui, s.id) : 'no strategy selected');
+            }
+            return say(e ? startBacktest(ui, e.id) : 'no strategy selected');
+        }
+        case 'autotrade.sweep': {
+            const id = ui.view === 'editor' && ui.editor ? ui.editor.id : ui.view === 'backtest' ? backtestSubject(ui)?.id : e?.id;
+            return say(id ? startSweep(ui, id) : 'no strategy selected');
+        }
+        case 'autotrade.proposal': return say(ui.view === 'list' ? openReview(ui) || null : 'o reviews chat proposals on the strategies list (esc)');
+        case 'autotrade.run':
+            ui.view = 'runner';
+            refreshRunner(ui);
+            reloadList(ui);
+            return say('starting and stopping a paper run ships with the runner (not in this build yet) · this view shows a runner as soon as one writes its status file');
+        case 'autotrade.kill':
+            refreshRunner(ui);
+            return say(runnerVerb(ui, 'kill'));
+        case 'autotrade.pause':
+            refreshRunner(ui);
+            return say(runnerVerb(ui, 'pause'));
+        case 'autotrade.flatten':
+            refreshRunner(ui);
+            return say(runnerVerb(ui, 'flatten'));
+        default: return false;
+    }
+}

package/dist/packages/cli/src/screens/autotrade-proposals.js

@@ -0,0 +1,123 @@
+// dexterm — chat proposals on the AUTOTRADE screen (task-1507 AT-5, AUTOTRADE-SPEC §2a). PAPER ONLY.
+//
+// The analyst (or any MCP agent) can only PROPOSE a strategy edit: `strategy_propose_edit/new` write a proposal file
+// and nothing else. This module is the ONLY path that applies one, and it runs only on the user's physical keys:
+//
+//   o   on the strategies list opens the diff card of the newest pending proposal (the selected strategy's first)
+//   y   applies a tighter or neutral edit
+//   y   on a LOOSER edit opens the "less safe" popup (every less-safe field named) and a SECOND y applies it
+//   n   dismisses the proposal · esc (or any other key) closes the card and leaves it pending
+//
+// Applying re-checks everything from scratch (`checkProposal`: the base hash, the model deny-list on the result,
+// the validator and a fresh risk delta: the stored riskDelta is never trusted), then writes through StrategyStore
+// (a new version, one `.journal.jsonl` line naming the proposer, the proposal id, the ops and both hashes).
+// The key loop feeds `reviewKey` decoded keyboard keys only; no voice, pipe or agent path reaches it.
+import { applyOps, dextermHome } from '../../../custom/src/index.js';
+import * as engine from '../../../autotrade/src/index.js';
+import { ProposalFiles, checkProposal, proposalCardView } from '../../../mcp/src/index.js';
+const ENGINE = { at: engine, applyOps };
+/** Pending proposals as display cards, re-read at most once a second (the list view asks every frame). */
+export function proposalSource(files, now = Date.now) {
+    let at = -Infinity;
+    let recs = [];
+    const pending = () => {
+        const t = now();
+        if (t - at >= 1000) {
+            try {
+                recs = files.list({ status: 'pending' });
+            }
+            catch {
+                recs = [];
+            }
+            at = t;
+        }
+        return recs;
+    };
+    return { pending, cards: () => pending().map(proposalCardView), invalidate: () => { at = -Infinity; } };
+}
+export const proposalFilesFor = (env = process.env) => new ProposalFiles(dextermHome(env));
+const inputOf = (r) => ({ kind: r.kind, id: r.id, ops: r.ops, from: r.from, name: r.name, why: r.why });
+/** Re-check a stored proposal against the strategy as it is NOW (stale when the strategy changed since). */
+export function recheck(store, rec) {
+    const c = checkProposal(ENGINE, store, inputOf(rec));
+    if (c.ok && c.before.hash !== rec.beforeHash) {
+        return { ok: false, stage: 'input', errors: [{ path: `/${rec.id}`, msg: `${rec.id} changed since this proposal (it was made on ${rec.beforeHash}, it is ${c.before.hash} now): dismiss it with n and ask again` }], warnings: [] };
+    }
+    return c;
+}
+/** The keys a proposal needs: one for a tighter or neutral edit, two (the less-safe popup) for a looser one. */
+export const keysNeeded = (c) => (c.ok && c.riskDelta === 'looser' ? 2 : 1);
+/**
+ * Apply a proposal. `keys` must be the physical keys the user pressed on its card (`reviewKey` collects them);
+ * a looser edit needs two. Returns the toast line. Nothing else in the app calls the store with a proposal id.
+ */
+export function applyProposal(store, files, rec, keys, now = Date.now()) {
+    if (rec.status !== 'pending')
+        return { ok: false, message: `proposal ${rec.proposalId} is already ${rec.status}` };
+    const c = recheck(store, rec);
+    if (!c.ok)
+        return { ok: false, message: `not applied: ${c.errors.map(engine.fmtIssue).join('; ')}` };
+    const yes = keys.filter((k) => k === 'y').length;
+    const need = keysNeeded(c);
+    if (yes < need)
+        return { ok: false, message: `not applied: a LOOSER edit needs a second keypress (${yes} of ${need})` };
+    const why = `${rec.why} · applied by keypress${need === 2 ? ' after the less-safe popup' : ''}`.slice(0, 300);
+    const w = rec.kind === 'edit'
+        ? store.patch(rec.id, c.effectiveOps, { actor: rec.actor, why, proposalId: rec.proposalId })
+        : store.create(c.afterRaw, { actor: rec.actor, why, from: rec.from, proposalId: rec.proposalId });
+    if (!w.ok)
+        return { ok: false, message: `not applied: ${w.errors.map(engine.fmtIssue).join('; ')}` };
+    if (w.strategy.hash !== c.after.hash)
+        return { ok: false, message: `applied, but the stored hash ${w.strategy.hash} differs from the proposal's ${c.after.hash}: check the journal` };
+    files.resolve(rec.proposalId, 'applied', { appliedVersion: w.strategy.version, keys: [...keys] }, now);
+    return { ok: true, message: `${rec.kind === 'new' ? 'created' : 'applied'} ${rec.id} v${w.strategy.version} (${c.riskDelta}) · journaled with ${rec.proposalId}` };
+}
+// ───────────────────────────── the card's keys (AutotradeUi) ─────────────────────────────
+/** `o`: open the newest pending proposal (the selected strategy's first). Returns the notice. */
+export function openReview(ui) {
+    const src = ui.deps.proposalSource;
+    if (!src)
+        return 'chat proposals are not available on this run';
+    src.invalidate();
+    const pending = src.pending();
+    if (!pending.length)
+        return 'no chat proposals · ask the analyst (a) to change a strategy; its diff card shows up here';
+    const sel = ui.entries[ui.selected]?.id;
+    const rec = pending.find((p) => p.id === sel) ?? pending[0];
+    ui.review = { rec, check: recheck(ui.deps.store, rec), stage: 'card', keys: [] };
+    return '';
+}
+/** A key while the card is open. Returns the notice (null keeps the card's own text). */
+export function reviewKey(ui, key) {
+    const rv = ui.review;
+    if (!rv)
+        return null;
+    const ch = key.name === 'char' && !key.ctrl && !key.alt ? key.ch : null;
+    const src = ui.deps.proposalSource;
+    const files = ui.deps.proposalFiles;
+    if (ch === 'n' && files) {
+        files.resolve(rv.rec.proposalId, 'dismissed', {}, ui.deps.now());
+        ui.review = null;
+        src?.invalidate();
+        return `dismissed ${rv.rec.proposalId} (${rv.rec.id} unchanged)`;
+    }
+    if (ch !== 'y') {
+        ui.review = null;
+        return 'proposal left pending (o reopens it)';
+    }
+    if (!rv.check.ok)
+        return `cannot apply: ${rv.check.errors.map(engine.fmtIssue).join('; ')} · n dismisses it`;
+    rv.keys.push('y');
+    if (rv.check.riskDelta === 'looser' && rv.stage === 'card') {
+        rv.stage = 'less-safe';
+        return 'LESS SAFE: y again applies it · any other key cancels';
+    }
+    if (!files) {
+        ui.review = null;
+        return 'chat proposals are not available on this run';
+    }
+    const r = applyProposal(ui.deps.store, files, rv.rec, rv.keys, ui.deps.now());
+    ui.review = null;
+    src?.invalidate();
+    return r.message;
+}