@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-HSQQFDB3.js

@@ -0,0 +1,519 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  column,
+  terminalColumns,
+  truncate
+} from "./chunk-ZIDFQJRB.js";
+import {
+  source_default
+} from "./chunk-SQZHXUB3.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/select.ts
+init_esm_shims();
+import { emitKeypressEvents } from "node:readline";
+function canSelect(input = process.stdin, output = process.stdout) {
+  return Boolean(input.isTTY && output.isTTY && typeof input.setRawMode === "function" && process.env.TERM !== "dumb");
+}
+var ESC = "\x1B";
+var CURSOR_HIDE = `${ESC}[?25l`;
+var CURSOR_SHOW = `${ESC}[?25h`;
+var ANSI_PATTERN = new RegExp(`${ESC}\\[[0-9;?]*[A-Za-z]`, "gu");
+function printedWidth(text) {
+  return text.replace(ANSI_PATTERN, "").length;
+}
+function headingLines(heading) {
+  if (heading === void 0) return [];
+  return typeof heading === "string" ? [heading] : [...heading];
+}
+async function readKeys(input, output, hideCursor, onStart, onKey, onEnd) {
+  const wasRaw = input.isRaw === true;
+  emitKeypressEvents(input);
+  input.setRawMode(true);
+  input.resume();
+  if (hideCursor) output.write(CURSOR_HIDE);
+  onStart();
+  try {
+    return await new Promise((resolve) => {
+      const finish = (result) => {
+        input.off("keypress", handleKey);
+        input.off("end", handleEnd);
+        input.off("close", handleEnd);
+        resolve(result);
+      };
+      function handleEnd() {
+        finish(onEnd());
+      }
+      function handleKey(str, key) {
+        onKey(str, key ?? {}, finish);
+      }
+      input.on("keypress", handleKey);
+      input.once("end", handleEnd);
+      input.once("close", handleEnd);
+    });
+  } finally {
+    if (hideCursor) output.write(CURSOR_SHOW);
+    if (!wasRaw) input.setRawMode(false);
+    input.pause();
+  }
+}
+function makeFrame(output) {
+  let drawn = 0;
+  return {
+    draw(lines) {
+      if (drawn > 0) output.write(`${ESC}[${drawn}A${ESC}[0J`);
+      output.write(`${lines.join("\n")}
+`);
+      drawn = lines.length;
+    },
+    erase() {
+      if (drawn > 0) output.write(`${ESC}[${drawn}A${ESC}[0J`);
+      drawn = 0;
+    },
+    drawn: () => drawn
+  };
+}
+function choiceRows(spec, index, windowStart, viewport) {
+  const { choices, rail, railWidth, output, markerWidth, marker } = spec;
+  const room = terminalColumns(output) - railWidth;
+  const hasHints = choices.some((choice) => choice.hint !== void 0);
+  const labelWidth = Math.min(30, Math.max(...choices.map((choice) => choice.label.length)));
+  const hintRoom = room - markerWidth - labelWidth - 2;
+  const end = Math.min(choices.length, windowStart + viewport);
+  const lines = [];
+  if (windowStart > 0) lines.push(`${rail}${source_default.dim(`  \u2191 ${windowStart} more`)}`);
+  for (let position = windowStart; position < end; position++) {
+    const choice = choices[position];
+    if (choice === void 0) continue;
+    const active = position === index;
+    const aligned = hasHints && hintRoom >= 12;
+    const label = aligned ? column(choice.label, labelWidth) : truncate(choice.label, room - markerWidth);
+    const hint = aligned && choice.hint !== void 0 ? truncate(choice.hint, hintRoom) : "";
+    const styledLabel = active ? source_default.cyan.bold(label) : label;
+    lines.push(`${rail}${marker(position)}${styledLabel}${hint.length > 0 ? `  ${source_default.dim(hint)}` : ""}`.trimEnd());
+  }
+  if (end < choices.length) lines.push(`${rail}${source_default.dim(`  \u2193 ${choices.length - end} more`)}`);
+  return lines;
+}
+function viewportFor(output, overhead, total, requested) {
+  if (requested !== void 0) return Math.max(1, Math.min(total, requested));
+  const rows = typeof output.rows === "number" && output.rows > 0 ? output.rows : 24;
+  return Math.max(3, Math.min(total, rows - overhead));
+}
+async function promptSelect(options) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  let choices = options.choices;
+  if (choices.length === 0) return { kind: "back" };
+  const rail = options.railPrefix ?? "";
+  const railWidth = 3;
+  const head = headingLines(options.heading);
+  const frame = makeFrame(output);
+  let index = Math.min(Math.max(options.initialIndex ?? 0, 0), choices.length - 1);
+  let windowStart = 0;
+  let query = "";
+  const filter = () => {
+    choices = options.choices.filter((choice) => choice.label.toLowerCase().includes(query.toLowerCase()));
+    index = 0;
+    windowStart = 0;
+    render();
+  };
+  const render = () => {
+    const viewport = viewportFor(output, head.length + (options.searchable ? 6 : 5), choices.length, options.maxVisible);
+    if (index < windowStart) windowStart = index;
+    else if (index >= windowStart + viewport) windowStart = index - viewport + 1;
+    windowStart = Math.max(0, Math.min(windowStart, choices.length - viewport));
+    const lines = [];
+    for (const line of head) lines.push(`${rail}${line}`.trimEnd());
+    if (head.length > 0) lines.push(rail.trimEnd());
+    if (options.searchable)
+      lines.push(`${rail}${truncate(`Filter: ${query || "(type to search)"}`, terminalColumns(output) - railWidth)}`);
+    if (choices.length === 0) lines.push(`${rail}No matching models`);
+    lines.push(
+      ...choiceRows(
+        {
+          choices,
+          rail,
+          railWidth,
+          output,
+          markerWidth: 2,
+          marker: (position) => `${position === index ? source_default.cyan("\u276F") : " "} `
+        },
+        index,
+        windowStart,
+        viewport
+      )
+    );
+    lines.push(rail.trimEnd());
+    const legend = ["\u2191/\u2193 move", "enter select"];
+    if (options.backLabel !== void 0 && options.backLabel !== "quit") legend.push(`esc ${options.backLabel}`);
+    if (options.searchable) legend.push("type to filter", "ctrl-u clear", "ctrl-c quit");
+    else legend.push(options.backLabel === "quit" ? "esc or q quit" : "q quit");
+    lines.push(`${rail}${source_default.dim(legend.join(" \xB7 "))}`);
+    frame.draw(lines);
+  };
+  const result = await readKeys(
+    input,
+    output,
+    true,
+    render,
+    (str, key, finish) => {
+      if (key.ctrl && (key.name === "c" || key.name === "d")) {
+        finish({ kind: "quit" });
+        return;
+      }
+      if (options.searchable) {
+        if (key.ctrl && key.name === "u") {
+          query = "";
+          filter();
+          return;
+        }
+        if (key.name === "backspace") {
+          query = query.slice(0, -1);
+          filter();
+          return;
+        }
+        if (!key.ctrl && !key.meta && str?.length === 1 && str >= " " && str !== "\x7F") {
+          query += str;
+          filter();
+          return;
+        }
+        if (choices.length === 0 && !["escape", "left"].includes(key.name ?? "")) return;
+      }
+      switch (key.name) {
+        case "up":
+        case "k":
+          index = (index - 1 + choices.length) % choices.length;
+          render();
+          return;
+        case "down":
+        case "j":
+        case "tab":
+          index = (index + 1) % choices.length;
+          render();
+          return;
+        case "pageup":
+          index = Math.max(0, index - 5);
+          render();
+          return;
+        case "pagedown":
+          index = Math.min(choices.length - 1, index + 5);
+          render();
+          return;
+        case "home":
+          index = 0;
+          render();
+          return;
+        case "end":
+          index = choices.length - 1;
+          render();
+          return;
+        case "return":
+        case "enter":
+        case "space": {
+          const choice = choices[index];
+          finish(choice === void 0 ? { kind: "back" } : { kind: "selected", value: choice.value });
+          return;
+        }
+        case "escape":
+        case "left":
+        case "backspace":
+          finish({ kind: "back" });
+          return;
+        case "q":
+          finish({ kind: "quit" });
+          return;
+        default: {
+          const digit = Number.parseInt(key.name ?? "", 10);
+          if (Number.isInteger(digit) && digit >= 1 && digit <= choices.length) {
+            index = digit - 1;
+            render();
+            const choice = choices[index];
+            if (choice !== void 0) finish({ kind: "selected", value: choice.value });
+          }
+        }
+      }
+    },
+    () => ({ kind: "quit" })
+  );
+  if (options.clearOnExit) frame.erase();
+  return result;
+}
+async function promptMultiSelect(options) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const choices = options.choices;
+  if (choices.length === 0) return { kind: "selected", values: [] };
+  const rail = options.railPrefix ?? "";
+  const railWidth = 3;
+  const head = headingLines(options.heading);
+  const frame = makeFrame(output);
+  const checked = choices.map((choice) => choice.checked === true);
+  let index = 0;
+  let windowStart = 0;
+  const render = () => {
+    const viewport = viewportFor(output, head.length + 5, choices.length, options.maxVisible);
+    if (index < windowStart) windowStart = index;
+    else if (index >= windowStart + viewport) windowStart = index - viewport + 1;
+    windowStart = Math.max(0, Math.min(windowStart, choices.length - viewport));
+    const lines = [];
+    for (const line of head) lines.push(`${rail}${line}`.trimEnd());
+    if (head.length > 0) lines.push(rail.trimEnd());
+    lines.push(
+      ...choiceRows(
+        {
+          choices,
+          rail,
+          railWidth,
+          output,
+          markerWidth: 4,
+          marker: (position) => {
+            const cursor = position === index ? source_default.cyan("\u276F") : " ";
+            const box = checked[position] === true ? source_default.green("\u25C9") : source_default.dim("\u25CB");
+            return `${cursor} ${box} `;
+          }
+        },
+        index,
+        windowStart,
+        viewport
+      )
+    );
+    lines.push(rail.trimEnd());
+    const legend = ["\u2191/\u2193 move", "space toggle", `enter ${options.confirmLabel ?? "confirm"}`];
+    if (options.backLabel !== void 0) legend.push(`esc ${options.backLabel}`);
+    lines.push(`${rail}${source_default.dim(legend.join(" \xB7 "))}`);
+    frame.draw(lines);
+  };
+  const result = await readKeys(
+    input,
+    output,
+    true,
+    render,
+    (_str, key, finish) => {
+      if (key.ctrl && (key.name === "c" || key.name === "d")) {
+        finish({ kind: "quit" });
+        return;
+      }
+      switch (key.name) {
+        case "up":
+        case "k":
+          index = (index - 1 + choices.length) % choices.length;
+          render();
+          return;
+        case "down":
+        case "j":
+        case "tab":
+          index = (index + 1) % choices.length;
+          render();
+          return;
+        case "home":
+          index = 0;
+          render();
+          return;
+        case "end":
+          index = choices.length - 1;
+          render();
+          return;
+        case "space":
+          checked[index] = checked[index] !== true;
+          render();
+          return;
+        case "a":
+          {
+            const turnOn = checked.some((value) => !value);
+            checked.fill(turnOn);
+          }
+          render();
+          return;
+        case "return":
+        case "enter":
+          finish({
+            kind: "selected",
+            values: choices.filter((_choice, position) => checked[position] === true).map((choice) => choice.value)
+          });
+          return;
+        case "escape":
+        case "left":
+          finish({ kind: "back" });
+          return;
+        default: {
+          const digit = Number.parseInt(key.name ?? "", 10);
+          if (Number.isInteger(digit) && digit >= 1 && digit <= choices.length) {
+            index = digit - 1;
+            checked[index] = checked[index] !== true;
+            render();
+          }
+        }
+      }
+    },
+    () => ({ kind: "quit" })
+  );
+  if (options.clearOnExit) frame.erase();
+  return result;
+}
+function typedText(str, key) {
+  if (key.ctrl === true || key.meta === true) return null;
+  if (typeof str !== "string" || str.length === 0) return null;
+  if (/[\u0000-\u001F\u007F]/u.test(str)) return null;
+  return str;
+}
+async function promptText(options) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const rail = options.railPrefix ?? "";
+  const railWidth = printedWidth(rail);
+  const head = headingLines(options.heading);
+  const frame = makeFrame(output);
+  let value = options.initial ?? "";
+  let caret = value.length;
+  let error = null;
+  let below = 0;
+  let parked = false;
+  const render = () => {
+    if (parked) {
+      output.write(`\r${below > 0 ? `${ESC}[${below}B` : ""}`);
+      parked = false;
+    }
+    const room = Math.max(8, terminalColumns(output) - railWidth - 2);
+    const shown = options.mask === true ? "\u2022".repeat(value.length) : value;
+    const lines = [];
+    for (const line of head) lines.push(`${rail}${line}`.trimEnd());
+    if (head.length > 0) lines.push(rail.trimEnd());
+    const fieldIndex = lines.length;
+    lines.push(`${rail}${source_default.cyan("\u276F")} ${truncate(shown, room)}`);
+    if (error !== null) lines.push(`${rail}${source_default.yellow(truncate(error, room))}`);
+    else if (options.hint !== void 0) lines.push(`${rail}${source_default.dim(truncate(options.hint, room))}`);
+    lines.push(rail.trimEnd());
+    const legend = ["enter accept"];
+    if (options.backLabel !== void 0) legend.push(`esc ${options.backLabel}`);
+    legend.push("ctrl-c quit");
+    lines.push(`${rail}${source_default.dim(legend.join(" \xB7 "))}`);
+    frame.draw(lines);
+    below = lines.length - fieldIndex;
+    const columnOffset = railWidth + 2 + Math.min(caret, room);
+    output.write(`${ESC}[${below}A\r${columnOffset > 0 ? `${ESC}[${columnOffset}C` : ""}`);
+    parked = true;
+  };
+  const unpark = () => {
+    if (!parked) return;
+    output.write(`\r${below > 0 ? `${ESC}[${below}B` : ""}`);
+    parked = false;
+  };
+  const result = await readKeys(
+    input,
+    output,
+    false,
+    render,
+    (str, key, finish) => {
+      if (key.ctrl === true) {
+        switch (key.name) {
+          case "c":
+          case "d":
+            unpark();
+            finish({ kind: "quit" });
+            return;
+          case "a":
+            caret = 0;
+            render();
+            return;
+          case "e":
+            caret = value.length;
+            render();
+            return;
+          case "u":
+            value = value.slice(caret);
+            caret = 0;
+            render();
+            return;
+          case "k":
+            value = value.slice(0, caret);
+            render();
+            return;
+          case "w": {
+            const head_ = value.slice(0, caret).replace(/\S+\s*$/u, "");
+            value = head_ + value.slice(caret);
+            caret = head_.length;
+            render();
+            return;
+          }
+          default:
+            return;
+        }
+      }
+      switch (key.name) {
+        case "escape":
+          unpark();
+          finish({ kind: "back" });
+          return;
+        case "return":
+        case "enter": {
+          const answer = value.trim();
+          const reason = options.validate?.(answer) ?? null;
+          if (reason !== null) {
+            error = reason;
+            render();
+            return;
+          }
+          unpark();
+          finish({ kind: "value", value: answer });
+          return;
+        }
+        case "backspace":
+          if (caret > 0) {
+            value = value.slice(0, caret - 1) + value.slice(caret);
+            caret -= 1;
+            error = null;
+            render();
+          }
+          return;
+        case "delete":
+          if (caret < value.length) {
+            value = value.slice(0, caret) + value.slice(caret + 1);
+            error = null;
+            render();
+          }
+          return;
+        case "left":
+          caret = Math.max(0, caret - 1);
+          render();
+          return;
+        case "right":
+          caret = Math.min(value.length, caret + 1);
+          render();
+          return;
+        case "home":
+          caret = 0;
+          render();
+          return;
+        case "end":
+          caret = value.length;
+          render();
+          return;
+        default: {
+          const typed = typedText(str, key);
+          if (typed === null) return;
+          value = value.slice(0, caret) + typed + value.slice(caret);
+          caret += typed.length;
+          error = null;
+          render();
+        }
+      }
+    },
+    () => {
+      unpark();
+      return { kind: "quit" };
+    }
+  );
+  if (options.clearOnExit) frame.erase();
+  return result;
+}
+
+export {
+  canSelect,
+  promptSelect,
+  promptMultiSelect,
+  promptText
+};
+//# sourceMappingURL=chunk-HSQQFDB3.js.map

package/dist/chunk-I4ELN5BX.js

@@ -0,0 +1,47 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  atomicWrite
+} from "./chunk-EKV4UBCM.js";
+import {
+  clioStateDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/dispatch/code-step-store.ts
+init_esm_shims();
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function codeStepDir(rootId) {
+  return join(clioStateDir(), "code-steps", rootId);
+}
+function codeStepRecordPath(rootId, runId) {
+  return join(codeStepDir(rootId), `${runId}.json`);
+}
+async function writeCodeStepRecord(rootId, record) {
+  const path = codeStepRecordPath(rootId, record.runId);
+  await atomicWrite(path, `${JSON.stringify(record, null, 2)}
+`);
+  return path;
+}
+function readCodeStepRecords(rootId) {
+  const dir = codeStepDir(rootId);
+  if (!existsSync(dir)) return [];
+  const records = [];
+  for (const file of readdirSync(dir).filter((name) => name.endsWith(".json")).sort()) {
+    try {
+      const parsed = JSON.parse(readFileSync(join(dir, file), "utf8"));
+      if (parsed.version === 1) records.push(parsed);
+    } catch {
+    }
+  }
+  return records.sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+}
+
+export {
+  codeStepDir,
+  writeCodeStepRecord,
+  readCodeStepRecords
+};
+//# sourceMappingURL=chunk-I4ELN5BX.js.map