dexterm-cli 0.1.6 → 0.2.0

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

@@ -0,0 +1,182 @@
+// 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";
+import { journeyForward, journeyPromote, journeyStopForward, openJourney, refreshJourney } from "./autotrade-journey.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 === 'journey' && ui.journey)
+                return say(startBacktest(ui, ui.journey.id));
+            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)');
+        // task-1647: the journey view
+        case 'autotrade.journey':
+            if (ui.view === 'journey') {
+                refreshJourney(ui, true);
+                return say(null);
+            }
+            return say(openJourney(ui, ui.view === 'editor' ? ui.editor?.id : ui.view === 'backtest' ? backtestSubject(ui)?.id : e?.id));
+        case 'autotrade.forward': return say(ui.view === 'journey' ? journeyForward(ui) : 'F starts a forward test on the journey view (J)');
+        case 'autotrade.forwardstop': return say(ui.view === 'journey' ? journeyStopForward(ui) : 'X stops a forward test on the journey view (J)');
+        case 'autotrade.promote': return say(ui.view === 'journey' ? journeyPromote(ui) : 'A reviews a promotion on the journey view (J)');
+        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;
+}