deepclause-sdk 0.2.2 → 0.4.0

package/dist/cli/repl.js

@@ -31,12 +31,15 @@ import { StatusBarComponent } from '../repl/tui/status-bar.js';
 import { Container, HStack, ScrollView, Spacer, TuiAltScreen, VStack, matchesKey, } from '@earendil-works/pi-tui';
 import { editorTheme, formatInputAnswer } from '../repl/tui/theme.js';
 import { PromptEditor } from '../repl/tui/editor.js';
+import { FormView } from '../repl/tui/form-view.js';
+import { applyFormKey, initialState, rows } from '../repl/form-widget.js';
 import { loadProjectContext } from '../repl/project-context.js';
 import { createPiBackend, THINKING_LEVELS } from '../repl/backend.js';
 import { createReplToolset } from '../repl/toolset.js';
 import { takeStartupPrologMessages } from '../prolog/loader.js';
 import { createPiImageBackend } from '../repl/imagegen.js';
 import { EnvModelResolver, PiModelResolver } from '../repl/model-resolver.js';
+import { pickForm } from '../repl/form-widget.js';
 import { parseModelId, resolveModelSlotConfig } from '../system/config/model-slots.js';
 import { loadReplConfig, resolveReplCompactionConfig, updateConfig } from './config.js';
 import { renderDiagramImage, resolveMedia, } from '../visualize/index.js';
@@ -232,6 +235,10 @@ export function classifyReplInput(line) {
 export async function runGoalWithRenderer(repl, goal, options) {
     let hadError = false;
     let printedAny = false;
+    let answered = false;
+    // A turn that suspended *succeeded* — it stopped at a safe point and the host
+    // recorded where to continue. Reporting `false.` would read as a failure.
+    let suspended = false;
     for await (const event of repl.query(goal, { signal: options.signal })) {
         if (event.type === 'solution') {
             options.renderer.solution(event.solution?.bindings ?? []);
@@ -243,6 +250,14 @@ export async function runGoalWithRenderer(repl, goal, options) {
             hadError = true;
             options.renderer.render(event);
         }
+        else if (event.type === 'answer') {
+            answered = true;
+            options.renderer.render(event);
+        }
+        else if (event.type === 'suspend') {
+            suspended = true;
+            options.renderer.render(event);
+        }
         else if (event.type === 'finished') {
             // Nothing to print for finished.
         }
@@ -250,11 +265,63 @@ export async function runGoalWithRenderer(repl, goal, options) {
             options.renderer.render(event);
         }
     }
-    if (!printedAny && !hadError) {
-        options.renderer.writeLine('false.');
+    if (!printedAny && !hadError && !suspended) {
+        // A goal that committed with `answer/1` succeeded; one that produced neither
+        // a solution nor an answer simply failed. (`goalTerminator`/`noSolution`
+        // keep `--json` stdout pure, where a raw `false.` would corrupt the stream.)
+        if (answered)
+            options.renderer.goalTerminator();
+        else
+            options.renderer.noSolution();
     }
     return hadError ? 1 : 0;
 }
+/**
+ * The REPL's form interaction (v0): a field-by-field wizard over the existing
+ * input channel. The pi-tui form widget is the next step (docs/DML_FORMS.md §9).
+ */
+async function presentFormWidget(repl, form) {
+    const spec = form.spec;
+    if (!spec)
+        return;
+    const change = await pickForm({ spec, values: form.values, issues: form.issues });
+    repl.session.submitForm(form.formId, change
+        ? { action: change.action, values: change.values }
+        : { action: 'cancel', values: form.values ?? {} });
+}
+/**
+ * The TUI/non-TTY form interaction: a field-by-field wizard over the existing
+ * input channel. The plain-TTY path uses the widget instead.
+ */
+async function presentForm(repl, form) {
+    const spec = form.spec;
+    if (!spec)
+        return;
+    const values = { ...(form.values ?? {}) };
+    const fields = (spec.fields ?? []).filter((field) => field.type !== 'object' && field.widget !== 'hidden');
+    for (const field of fields) {
+        const label = field.title ?? field.name;
+        const current = values[field.name];
+        const hint = current === undefined || current === '' ? '' : ` (${String(current)})`;
+        const answer = await repl.session.requestHumanInput(`${label}${field.required ? ' *' : ''}${hint}`);
+        if (answer === undefined) {
+            repl.session.submitForm(form.formId, { action: 'cancel', values });
+            return;
+        }
+        if (answer.trim() !== '')
+            values[field.name] = coerceFieldValue(field.type, answer.trim());
+    }
+    repl.session.submitForm(form.formId, { action: 'submit', values });
+}
+function coerceFieldValue(type, raw) {
+    if (type === 'number' || type === 'integer') {
+        const n = Number(raw);
+        return Number.isFinite(n) ? n : raw;
+    }
+    if (type === 'boolean')
+        return /^(y|yes|true|1)$/i.test(raw);
+    return raw;
+}
 function selectRenderMode(options) {
     if (options.json)
         return 'json';
@@ -262,6 +329,18 @@ function selectRenderMode(options) {
         return 'plain';
     return process.stdout.isTTY ? 'rich' : 'plain';
 }
+/**
+ * Should a form re-presented after a rejected submit be cancelled instead?
+ *
+ * A scripted run (`--answer`) supplies the same canned reply to every prompt. The
+ * host re-shows a refused submit so a *person* can correct it — but re-feeding the
+ * canned answer would refuse, re-show, refuse … forever. So in that mode the
+ * second presentation cancels and the run finishes. A model's own `update_form`
+ * carries no issues and is unaffected.
+ */
+export function cancelsScriptedRetry(options, form) {
+    return options.answer !== undefined && form.op === 'update' && (form.issues?.length ?? 0) > 0;
+}
 /**
  * Build the unified input channel from CLI flags (proposal §13.6):
  *  - `--answer` supplies a canned reply; `--no-ask` fails immediately;
@@ -270,7 +349,20 @@ function selectRenderMode(options) {
  */
 export function buildCliOnInput(options) {
     if (options.answer !== undefined) {
-        return async () => options.answer;
+        // A promptless request is `input/1` — the person's next chat message. A
+        // scripted run has exactly one conversation message; replaying it would make
+        // a chat loop turn forever, so after it there is nobody to talk to and the
+        // conversation ends. Prompted requests (a form field, a question) are not
+        // limited: the same canned reply answers each one.
+        let usedForMessage = false;
+        return async (prompt) => {
+            if (prompt === '') {
+                if (usedForMessage)
+                    return undefined;
+                usedForMessage = true;
+            }
+            return options.answer;
+        };
     }
     if (options.noAsk) {
         return async () => undefined;
@@ -379,7 +471,10 @@ export async function createReplRuntime(options) {
             llmBackend = pi.backend;
             harnessModel = pi.modelId.split('/').slice(1).join('/') || pi.modelId;
             harnessProvider = pi.provider ?? harnessProvider;
-            contextWindow = pi.contextWindow;
+            contextWindow = pi.contextWindow ?? resolveModelSlotConfig(config, 'run', {
+                modelId: options.model ?? config.models.run,
+                temperature: options.temperature ?? config.temperatures.run,
+            }).contextWindow;
             reasoning = pi.reasoning;
             thinkingLevel = pi.thinkingLevel;
             modelResolver = new PiModelResolver(pi.registry);
@@ -499,6 +594,15 @@ export async function createReplRuntime(options) {
         judgeSelection,
         imageBackend,
         modelResolver,
+        onForm: async (form) => {
+            if (cancelsScriptedRetry(options, form)) {
+                repl.session.submitForm(form.formId, { action: 'cancel', values: form.values ?? {} });
+                return;
+            }
+            return options.plain && process.stdin.isTTY && process.stdout.isTTY
+                ? presentFormWidget(repl, form)
+                : presentForm(repl, form);
+        },
         history: historyOptions,
         harness: harnessName,
         execution: options.execution,
@@ -553,6 +657,7 @@ export async function createReplRuntime(options) {
         historyEnabled: Boolean(historyOptions),
         inputHistory,
         statusSnapshot: () => statusTracker.snapshot(),
+        observeEvent: (event) => statusTracker.observe(event),
         tuiMode: options.tui ?? config.repl.tui ?? 'auto',
         setOnInput: (handler) => repl.setOnInput(handler),
         missingCredential,
@@ -637,6 +742,28 @@ async function printBanner(runtime, loaded) {
  * starting blank. Bounded, and skipped when the session was not resumed or
  * tracing was off.
  */
+/**
+ * Continue a session that was suspended with `suspend/1`.
+ *
+ * The turn stopped at a safe point and the host wrote the goal that resumes it
+ * (docs/DML_REPL_SUSPEND_RESUME.md). Resuming means running that goal once the
+ * harness and memory are restored — so `--session` picks the program up where it
+ * left off instead of dropping the user into a half-finished state. The record is
+ * cleared first: if the continuation suspends again it writes a fresh one.
+ */
+async function resumeSuspendedContinuation(runtime) {
+    const pending = runtime.repl.session.pendingSuspension?.();
+    if (!pending)
+        return;
+    runtime.renderer.writeLine(`resuming the suspended continuation: ${pending.continuation}`);
+    await runtime.repl.session.clearSuspension?.();
+    try {
+        await runGoalWithRenderer(runtime.repl, pending.continuation, { renderer: runtime.renderer });
+    }
+    catch (error) {
+        runtime.renderer.writeLine(`could not resume ${pending.continuation}: ${String(error.message)}`);
+    }
+}
 async function renderResumedSession(runtime) {
     const events = await runtime.repl.resumedTranscript().catch(() => []);
     if (events.length === 0)
@@ -1108,7 +1235,10 @@ export async function runInteractiveGoal(repl, renderer, goal, options, ask, sig
     finally {
         await iterator.return?.(undefined);
     }
-    renderer.writeLine(answered ? '.' : 'false.');
+    if (answered)
+        renderer.goalTerminator();
+    else
+        renderer.noSolution();
 }
 /**
  * Interactive TUI for the REPL: a scrolling transcript, a fixed editor, and a
@@ -1141,6 +1271,9 @@ export async function runTui(runtime, options, onExit, loaded = []) {
     const working = new WorkingLine(tui);
     const renderer = new TuiRenderer({
         document,
+        // The TUI draws through its own switch, but the status tracker must still see
+        // every event (usage, model_call, …) or the footer loses its counters.
+        onEvent: (event) => runtime.observeEvent(event),
         onWorking: (label) => {
             working.set(label);
             tui.requestRender();
@@ -1661,9 +1794,13 @@ export async function runTui(runtime, options, onExit, loaded = []) {
     // the first and last line of output are not jammed against the chrome. Fixed
     // spacers rather than padding inside the scroll view: they do not scroll away and
     // do not consume scrollback.
+    // The form panel: shown while a form is open, and the TUI edits its fields
+    // through the editor (one prompt each), updating this panel as it goes.
+    const formView = new FormView();
     const dock = new VStack([
         { component: working, basis: 'auto', grow: 0, shrink: 1, minSize: 0 },
         { component: servicesPanel, basis: 'auto', grow: 0, shrink: 1, minSize: 0 },
+        { component: formView, basis: 'auto', grow: 0, shrink: 1, minSize: 0 },
         { component: new Spacer(1), basis: 'auto', grow: 0, shrink: 1, minSize: 1 },
         { component: editorContainer, basis: 'auto', grow: 0, shrink: 1, minSize: 1 },
         { component: statusBar, basis: 'auto', grow: 0, shrink: 1, minSize: 1 },
@@ -1690,10 +1827,44 @@ export async function runTui(runtime, options, onExit, loaded = []) {
         ]));
     };
     applyLayout();
+    // A form opened by the running turn is shown in the dock and edited field by
+    // field through the editor; the plain-TTY path uses the raw widget instead.
+    runtime.repl.session.setFormHandler(async (form) => {
+        const spec = form.spec;
+        if (!spec)
+            return;
+        let state = initialState(spec, form.values ?? {}, form.issues ?? []);
+        formView.setState(state);
+        tui.requestRender();
+        const list = rows(spec);
+        try {
+            for (let index = 0; index < list.length; index += 1) {
+                const row = list[index];
+                if (row.kind !== 'field')
+                    continue;
+                const answer = await runtime.repl.session.requestHumanInput(`${row.title}${row.required ? ' *' : ''}`);
+                if (answer === undefined) {
+                    runtime.repl.session.submitForm(form.formId, { action: 'cancel', values: state.values });
+                    return;
+                }
+                if (answer !== '') {
+                    state = applyFormKey({ ...state, focus: index, editing: true, buffer: answer }, 'enter').state;
+                    formView.setState(state);
+                    tui.requestRender();
+                }
+            }
+            runtime.repl.session.submitForm(form.formId, { action: 'submit', values: state.values });
+        }
+        finally {
+            formView.setState(undefined);
+            tui.requestRender();
+        }
+    });
     tui.start();
     await printBanner(runtime, loaded);
     await renderResumedSession(runtime);
     tui.requestRender();
+    await resumeSuspendedContinuation(runtime);
     try {
         while (true) {
             // A slash command typed while a turn/command was running: run it now that
@@ -1883,6 +2054,7 @@ export async function startRepl(options) {
         }
         await printBanner(runtime, options.load ?? []);
         await renderResumedSession(runtime);
+        await resumeSuspendedContinuation(runtime);
         return await runInteractive(runtime, options, saveHarnessOnExit);
     }
     finally {