@iowarp/clio-coder 0.3.1 → 0.3.3

package/dist/steer-GGWFUJUD.js

@@ -0,0 +1,77 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  steerToolSurface
+} from "./chunk-WEH5XRJQ.js";
+import "./chunk-5B2AEOW5.js";
+import "./chunk-CGKSTWHD.js";
+import "./chunk-FCSXB6T2.js";
+import "./chunk-YXLYO42X.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/steer.ts
+init_esm_shims();
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "interrupted", "stale", "dead"]);
+function guide(deps, runId, message) {
+  if (message.length === 0) {
+    return { kind: "error", message: "steer: action=guide requires a non-empty message" };
+  }
+  try {
+    deps.dispatch.steer(runId, message);
+  } catch (err) {
+    return { kind: "error", message: err instanceof Error ? err.message : String(err) };
+  }
+  return {
+    kind: "ok",
+    output: `steer queued for run ${runId} (${message.length} chars); the worker sees it as a user message at its next turn boundary.`,
+    details: { action: "guide", runId, chars: message.length }
+  };
+}
+function cancel(deps, runId) {
+  const run = deps.dispatch.getRun(runId);
+  const rootRunId = run?.lineage?.rootRunId ?? runId;
+  const assignment = deps.dispatch.assignments?.getStored(rootRunId) ?? null;
+  if (!run && !assignment) return { kind: "error", message: `steer: unknown run or assignment '${runId}'` };
+  if (assignment?.status === "running") {
+    deps.dispatch.abort(rootRunId);
+    return {
+      kind: "ok",
+      output: `cancellation signalled for assignment ${rootRunId}; its current attempt will finalize and no future attempt will start.`,
+      details: { action: "cancel", runId: rootRunId, assignmentId: rootRunId }
+    };
+  }
+  if (!run || TERMINAL_STATUSES.has(run.status)) {
+    return {
+      kind: "error",
+      message: `steer: run or assignment '${runId}' already finished (state=${assignment?.status ?? run?.outcome ?? run?.status ?? "unknown"}); nothing to cancel`
+    };
+  }
+  deps.dispatch.abort(runId);
+  return {
+    kind: "ok",
+    output: `cancellation signalled for run ${runId}; the run finalizes with outcome=canceled and its receipt records the cancellation.`,
+    details: { action: "cancel", runId }
+  };
+}
+function createSteerTool(deps) {
+  return {
+    ...steerToolSurface,
+    async run(args) {
+      const runId = typeof args.run_id === "string" ? args.run_id.trim() : "";
+      if (runId.length === 0) return { kind: "error", message: "steer: missing run_id argument" };
+      const action = typeof args.action === "string" ? args.action : "";
+      if (action !== "guide" && action !== "cancel") {
+        return { kind: "error", message: `steer: action must be guide or cancel; got '${action}'` };
+      }
+      if (action === "guide") {
+        return guide(deps, runId, typeof args.message === "string" ? args.message.trim() : "");
+      }
+      return cancel(deps, runId);
+    }
+  };
+}
+export {
+  createSteerTool
+};
+//# sourceMappingURL=steer-GGWFUJUD.js.map

package/dist/{targets-TYXLPB23.js → targets-SNCPI2NR.js}

@@ -1,46 +1,46 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import "./chunk-4QKXUHSR.js";
-import {
-  ensureClioState
-} from "./chunk-ASND7OZK.js";
+import "./chunk-5UFT4SUX.js";
 import {
   ConfigDomainModule,
   loadDomains
-} from "./chunk-Q3RUPKEJ.js";
-import "./chunk-XYWBQRDM.js";
-import "./chunk-XPLRXC72.js";
-import "./chunk-474KN5II.js";
+} from "./chunk-OC7FIQPC.js";
+import {
+  ensureClioState
+} from "./chunk-UFIIWP2H.js";
+import "./chunk-CBCAPZAA.js";
+import "./chunk-4BPJXDWC.js";
+import "./chunk-2SFS6XQE.js";
+import "./chunk-ZWLZP4ZT.js";
 import "./chunk-CGKSTWHD.js";
-import "./chunk-C4PTHK7P.js";
+import "./chunk-XPLRXC72.js";
 import {
   runConfigureCommand,
   runTargetRemove,
   runTargetRename
-} from "./chunk-TEKV33Q5.js";
+} from "./chunk-X6IAEBZR.js";
+import "./chunk-2TLUCQVG.js";
+import "./chunk-BMEMKKIT.js";
 import "./chunk-2STGEDFV.js";
 import {
   column,
   terminalColumns,
   truncate
-} from "./chunk-IS3ONKU3.js";
-import "./chunk-PV4JUBVJ.js";
-import "./chunk-673JJUWJ.js";
-import "./chunk-RDLVBZEO.js";
+} from "./chunk-2IR2NMPA.js";
+import "./chunk-YCWGATWI.js";
 import {
   printError,
-  printOk,
+  printOk
+} from "./chunk-ED4KHGC3.js";
+import {
   source_default
-} from "./chunk-K2ITRMHZ.js";
+} from "./chunk-5TSRNF4G.js";
 import {
   ProvidersDomainModule,
   getRuntimeRegistry,
   isDispatchEligibleRuntime,
   isOrchestratorEligibleRuntime,
   registerBuiltinRuntimes
-} from "./chunk-H6F6BYOH.js";
-import "./chunk-EYOKLTMF.js";
-import "./chunk-IHXBNWMM.js";
-import "./chunk-Q5WJOSJ7.js";
+} from "./chunk-LZSJBIVT.js";
 import {
   bindAgentProfileInSettings,
   readSettings,
@@ -48,16 +48,29 @@ import {
   setFleetProfileInSettings,
   updateSettings,
   useTargetInSettings
-} from "./chunk-KY56HMHH.js";
+} from "./chunk-A3CYT5EX.js";
 import {
   THINKING_LEVELS
-} from "./chunk-NMOX6HFD.js";
-import "./chunk-GB6QRBXN.js";
-import "./chunk-3I7MS7N2.js";
-import "./chunk-HQQID6OA.js";
+} from "./chunk-ZDOOVTXZ.js";
+import "./chunk-4VP4KH3K.js";
+import "./chunk-M6SHUN7Q.js";
 import "./chunk-R346GLFC.js";
-import "./chunk-WEPFGWHJ.js";
+import "./chunk-VPAYEGVX.js";
+import "./chunk-COU2UHX6.js";
+import "./chunk-FQ4SKYE4.js";
+import "./chunk-IKCO5N3L.js";
+import "./chunk-3I7MS7N2.js";
+import "./chunk-IHXBNWMM.js";
+import "./chunk-SST6Z5JA.js";
+import "./chunk-4ZG3XFUR.js";
+import "./chunk-APJ265NV.js";
+import "./chunk-FCSXB6T2.js";
+import "./chunk-YXLYO42X.js";
 import "./chunk-BNAZZHFG.js";
+import "./chunk-6EJMN2Y3.js";
+import "./chunk-WEPFGWHJ.js";
+import "./chunk-TZTZS7QK.js";
+import "./chunk-OQ33BKR3.js";
 import "./chunk-IWHMRKLL.js";
 import {
   init_esm_shims
@@ -968,6 +981,9 @@ function serializeStatus(status, extras = {
   if (status.probeNotes !== void 0) {
     out.probeNotes = status.probeNotes;
   }
+  if (status.probeSurfaces !== void 0) {
+    out.probeSurfaces = status.probeSurfaces;
+  }
   return out;
 }
 export {
@@ -976,4 +992,4 @@ export {
   residentModelsSummary,
   runTargetsCommand
 };
-//# sourceMappingURL=targets-TYXLPB23.js.map
+//# sourceMappingURL=targets-SNCPI2NR.js.map

package/dist/terminal-lease-BNAHVHBS.js

@@ -0,0 +1,395 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  ClioEditor,
+  Container,
+  GLYPH,
+  ScrollView,
+  Text,
+  VStack,
+  clioTheme,
+  createKeybindingManager,
+  createProcessInteractiveShell,
+  matchesKey
+} from "./chunk-ZWMF7253.js";
+import {
+  getTerminationCoordinator
+} from "./chunk-TZTZS7QK.js";
+import "./chunk-OQ33BKR3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/interactive/terminal-lease.ts
+init_esm_shims();
+var INSTANT_SHELL_ENV = "CLIO_CODER_INSTANT_SHELL";
+var DOUBLE_TAP_MS = 500;
+var DIAGNOSTIC_LIMIT_BYTES = 64 * 1024;
+function instantShellEnabled(env = process.env) {
+  return env[INSTANT_SHELL_ENV] !== "0";
+}
+var RootHost = class extends VStack {
+  constructor(current) {
+    super();
+    this.replace(current);
+  }
+  replace(next) {
+    this.clear();
+    this.addChild(next, { grow: 1, shrink: 1, minSize: 1 });
+  }
+};
+var BootSubmissionPanel = class {
+  records = [];
+  set(records) {
+    this.records = [...records];
+  }
+  render(width) {
+    if (this.records.length === 0) return [];
+    const theme = clioTheme();
+    return this.records.map((record) => {
+      const oneLine = record.rawText.replace(/\s+/gu, " ").trim();
+      const room = Math.max(0, width - 11);
+      const preview = oneLine.length > room ? `${oneLine.slice(0, Math.max(0, room - 1))}\u2026` : oneLine;
+      return `${theme.fg("action", `${GLYPH.queued} queued`)} ${theme.fg("muted", preview)}`;
+    });
+  }
+  invalidate() {
+  }
+};
+function stageZeroRoot(mode, editor, pending, shutdownArmed) {
+  const theme = clioTheme();
+  const heading = new Text(
+    `${theme.style("title", ">C_ Clio Coder", { bold: true })}
+${theme.fg("muted", "Hydrating session services\u2026")}`,
+    0,
+    0
+  );
+  const footer = {
+    render: () => [
+      shutdownArmed() ? theme.fg("warning", "Ctrl+C again to exit \xB7 typed input will be recovered") : theme.fg("dim", "Warming up \xB7 typing and submit are ready")
+    ],
+    invalidate: () => {
+    }
+  };
+  if (mode === "fullscreen") {
+    const document = new Container();
+    document.addChild(heading);
+    const transcript = new ScrollView(document, { follow: "end", primary: true, overscroll: "chain" });
+    const dock = new VStack();
+    dock.addChild(pending, { shrink: 1, minSize: 0 });
+    dock.addChild(editor, { shrink: 1, minSize: 3 });
+    dock.addChild(footer, { shrink: 1, minSize: 1 });
+    const root2 = new VStack();
+    root2.addChild(transcript, { basis: 0, grow: 1, shrink: 1, minSize: 1 });
+    root2.addChild(dock, { basis: "auto", grow: 0, shrink: 1, minSize: 1 });
+    return root2;
+  }
+  const root = new Container();
+  root.addChild(heading);
+  root.addChild(pending);
+  root.addChild(editor);
+  root.addChild(footer);
+  return root;
+}
+function recoveryText(records, draft) {
+  if (records.length === 0 && draft.length === 0) return null;
+  const sections = records.map((record) => `[queued ${record.sequence}] ${record.rawText}`);
+  if (draft.length > 0) sections.push(`[draft] ${draft}`);
+  return `Clio Coder recovered input from an interrupted boot; copy and resubmit after restart:
+${sections.join("\n")}`;
+}
+function createProcessTerminalLease(options) {
+  const settings = options.settings;
+  const keybindings = createKeybindingManager(settings);
+  let editorChrome = {
+    getModelLabel: () => [settings.orchestrator.target, settings.orchestrator.model].filter((part) => part && part.length > 0).join("\xB7") || "starting",
+    getThinkingLabel: () => settings.orchestrator.thinkingLevel ?? "off",
+    getSubmitKeyLabel: () => keybindings.getKeys("tui.input.submit")[0] ?? "Enter",
+    getNewlineKeyLabel: () => keybindings.getKeys("tui.input.newLine")[0] ?? "Shift+Enter"
+  };
+  const editorChromeProxy = {
+    getModelLabel: () => editorChrome.getModelLabel(),
+    getThinkingLabel: () => editorChrome.getThinkingLabel(),
+    isStreaming: () => editorChrome.isStreaming?.() ?? false,
+    willEnterSteer: (text) => editorChrome.willEnterSteer?.(text) ?? false,
+    getSubmitKeyLabel: () => editorChrome.getSubmitKeyLabel?.() ?? "Enter",
+    getNewlineKeyLabel: () => editorChrome.getNewlineKeyLabel?.() ?? "Shift+Enter"
+  };
+  const shell = options.testing?.shell ?? createProcessInteractiveShell({
+    tuiMode: settings.terminal.tuiMode,
+    ...options.onStage0Commit ? { onFirstFrameCommit: options.onStage0Commit } : {}
+  });
+  const tui = shell.tui;
+  const editor = new ClioEditor(tui, editorChromeProxy);
+  editor.focused = true;
+  const pendingPanel = new BootSubmissionPanel();
+  let shutdownArmed = false;
+  const stage0 = stageZeroRoot(settings.terminal.tuiMode, editor, pendingPanel, () => shutdownArmed);
+  const host = new RootHost(stage0);
+  let state = "created";
+  let epoch = 0;
+  const bootAbort = new AbortController();
+  let sequence = 0;
+  const submissions = [];
+  const diagnostics = [];
+  const deferredDiagnostics = [];
+  let diagnosticBytes = 0;
+  let deferredDiagnosticBytes = 0;
+  let diagnosticsTruncated = false;
+  let deferredDiagnosticsTruncated = false;
+  let inputDelegate;
+  let applicationInput = null;
+  let applicationSignal = null;
+  let lastCtrlCAt = 0;
+  let closePromise = null;
+  let inputDisposed = false;
+  let signalDisposed = false;
+  const termination = options.testing?.termination ?? getTerminationCoordinator();
+  const signals = options.testing?.signals ?? process;
+  const now = options.testing?.now ?? Date.now;
+  const write = options.testing?.write ?? ((stream, text) => {
+    (stream === "stdout" ? process.stdout : process.stderr).write(text);
+  });
+  termination.installSignalHandlers();
+  const restoreInterruptOwner = termination.releaseInterruptOwnership();
+  const requestShutdown = () => {
+    void (async () => {
+      let cleanupError;
+      try {
+        await lease.close({ recoverInput: state !== "adopted" });
+      } catch (error) {
+        cleanupError = error;
+      }
+      if (options.shutdown) await options.shutdown(0);
+      else await termination.shutdown(0);
+      if (cleanupError) throw cleanupError;
+    })().catch((error) => {
+      try {
+        write(
+          "stderr",
+          `Clio Coder: terminal shutdown failed: ${error instanceof Error ? error.message : String(error)}
+`
+        );
+      } catch {
+      }
+    });
+  };
+  const handleStage0CtrlC = () => {
+    const text = editor.getText();
+    if (text.length > 0) {
+      editor.setText("");
+      shutdownArmed = false;
+      lastCtrlCAt = 0;
+      tui.requestRender();
+      return;
+    }
+    const pressedAt = now();
+    if (lastCtrlCAt > 0 && pressedAt - lastCtrlCAt <= DOUBLE_TAP_MS) {
+      lastCtrlCAt = 0;
+      requestShutdown();
+      return;
+    }
+    lastCtrlCAt = pressedAt;
+    shutdownArmed = true;
+    tui.requestRender();
+  };
+  inputDelegate = (data) => {
+    if (matchesKey(data, "ctrl+c")) {
+      handleStage0CtrlC();
+      return { consume: true };
+    }
+    if (keybindings.matches(data, "clio.exit") && editor.getText().length === 0) {
+      requestShutdown();
+      return { consume: true };
+    }
+    return void 0;
+  };
+  editor.onSubmit = (rawText) => {
+    const record = Object.freeze({ sequence: ++sequence, rawText, submittedAt: performance.now() });
+    submissions.push(record);
+    pendingPanel.set(submissions);
+    tui.requestRender();
+  };
+  const stableInput = (data) => inputDelegate(data);
+  const removeStableInput = tui.addInputListener(stableInput);
+  const stableSignal = () => {
+    if (applicationSignal) applicationSignal();
+    else handleStage0CtrlC();
+  };
+  signals.on("SIGINT", stableSignal);
+  const disposeStableOwners = () => {
+    if (!inputDisposed) {
+      inputDisposed = true;
+      removeStableInput();
+    }
+    if (!signalDisposed) {
+      signalDisposed = true;
+      signals.off("SIGINT", stableSignal);
+      restoreInterruptOwner();
+    }
+  };
+  const flushDiagnostics = () => {
+    for (const diagnostic of [...diagnostics.splice(0), ...deferredDiagnostics.splice(0)]) {
+      write(diagnostic.stream, diagnostic.text);
+    }
+  };
+  const enqueueDiagnostic = (stream, text, deferred) => {
+    const target = deferred ? deferredDiagnostics : diagnostics;
+    const bytes = Buffer.byteLength(text, "utf8");
+    const used = deferred ? deferredDiagnosticBytes : diagnosticBytes;
+    if (used + bytes <= DIAGNOSTIC_LIMIT_BYTES) {
+      target.push(Object.freeze({ stream, text }));
+      if (deferred) deferredDiagnosticBytes += bytes;
+      else diagnosticBytes += bytes;
+      return;
+    }
+    const alreadyTruncated = deferred ? deferredDiagnosticsTruncated : diagnosticsTruncated;
+    if (alreadyTruncated) return;
+    if (deferred) deferredDiagnosticsTruncated = true;
+    else diagnosticsTruncated = true;
+    target.push({ stream: "stderr", text: "Clio Coder: additional boot diagnostics were truncated.\n" });
+  };
+  const lease = {
+    shell,
+    terminal: shell.terminal,
+    tui,
+    editor,
+    keybindings,
+    pending: pendingPanel,
+    get state() {
+      return state;
+    },
+    get epoch() {
+      return epoch;
+    },
+    get abortSignal() {
+      return bootAbort.signal;
+    },
+    writeDiagnostic(stream, text) {
+      if (state === "closed") {
+        write(stream, text);
+        return;
+      }
+      enqueueDiagnostic(stream, text, false);
+    },
+    deferDiagnostic(stream, text) {
+      if (state === "closed") {
+        write(stream, text);
+        return;
+      }
+      enqueueDiagnostic(stream, text, true);
+    },
+    takeDiagnostics() {
+      const taken = diagnostics.splice(0);
+      diagnosticBytes = 0;
+      return taken;
+    },
+    registerApplicationInput(delegate) {
+      applicationInput = delegate;
+      return () => {
+        if (applicationInput === delegate) applicationInput = null;
+      };
+    },
+    applicationSignals: {
+      takeInterruptOwnership: () => () => {
+      },
+      on: (_signal, listener) => {
+        applicationSignal = listener;
+      },
+      off: (_signal, listener) => {
+        if (applicationSignal === listener) applicationSignal = null;
+      }
+    },
+    adopt(adoption) {
+      if (state !== "mounted" || bootAbort.signal.aborted || !applicationInput) return false;
+      state = "adopting";
+      const adoptedEpoch = epoch;
+      editorChrome = adoption.editorChrome;
+      inputDelegate = applicationInput;
+      host.replace(adoption.root);
+      tui.setFocus(editor);
+      state = "adopted";
+      const hydratedFrame = shell.nextCommittedFrame();
+      tui.requestRender();
+      void hydratedFrame.then((frameId) => {
+        if (epoch === adoptedEpoch && state === "adopted") adoption.onHydratedFrame?.(frameId);
+      });
+      void (async () => {
+        for (const record of [...submissions]) {
+          if (epoch !== adoptedEpoch || state !== "adopted") return;
+          await adoption.admitSubmission(record);
+          if (epoch !== adoptedEpoch || state !== "adopted") return;
+          const index = submissions.findIndex((entry) => entry.sequence === record.sequence);
+          if (index >= 0) submissions.splice(index, 1);
+          pendingPanel.set(submissions);
+          tui.requestRender();
+        }
+      })().catch((error) => {
+        if (bootAbort.signal.aborted) return;
+        lease.writeDiagnostic(
+          "stderr",
+          `Clio Coder: queued boot submission failed: ${error instanceof Error ? error.message : String(error)}
+`
+        );
+      });
+      return true;
+    },
+    close(closeOptions = {}) {
+      if (closePromise) return closePromise;
+      state = "closing";
+      epoch += 1;
+      closePromise = (async () => {
+        const errors = [];
+        const attempt = (operation) => {
+          try {
+            operation();
+          } catch (error) {
+            errors.push(error);
+          }
+        };
+        try {
+          attempt(() => bootAbort.abort());
+          attempt(() => disposeStableOwners());
+          attempt(() => shell.releaseAnchor());
+          attempt(() => shell.stop());
+          try {
+            await shell.settle();
+          } catch (error) {
+            errors.push(error);
+          }
+          attempt(() => flushDiagnostics());
+          if (closeOptions.recoverInput || submissions.length > 0 || editor.getText().length > 0) {
+            attempt(() => {
+              const recovered = recoveryText(submissions, editor.getText());
+              if (recovered) write("stderr", `${recovered}
+`);
+            });
+          }
+        } finally {
+          state = "closed";
+        }
+        if (errors.length > 0) throw new AggregateError(errors, "terminal lease cleanup failed");
+      })();
+      return closePromise;
+    },
+    fail() {
+      return lease.close({ recoverInput: true });
+    }
+  };
+  termination.onDrain(() => lease.close({ recoverInput: state !== "adopted" }));
+  try {
+    shell.mount(host, editor);
+    state = "mounted";
+    tui.renderNow(false);
+  } catch (error) {
+    void lease.close({ recoverInput: true }).catch(() => {
+    });
+    throw error;
+  }
+  return lease;
+}
+export {
+  INSTANT_SHELL_ENV,
+  createProcessTerminalLease,
+  instantShellEnabled
+};
+//# sourceMappingURL=terminal-lease-BNAHVHBS.js.map