jules-orchestrator-kit 0.52.7 → 0.53.0

package/src/ux/swarm-model.mjs

@@ -1,146 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { createHash } from "node:crypto";
-
-/**
- * @typedef {"idle" | "reserved" | "preparing" | "running" | "verifying" | "draining" | "failed" | "stale"} SlotState
- *
- * @typedef {Object} SwarmSlot
- * @property {string} id
- * @property {SlotState} state
- * @property {string} [taskId]
- * @property {number} [attempt]
- * @property {string} [worktree]
- * @property {string} [branch]
- * @property {number} [pid]
- * @property {string} [processStartTime]
- * @property {string} [startedAt]
- * @property {number} [durationMs]
- * @property {string[]} lockIds
- * @property {string[]} writeScope
- * @property {number} [cpuPercent]
- * @property {number} [rssBytes]
- * @property {"full" | "partial" | "unavailable"} resourceSupport
- * @property {string} [lastHeartbeat]
- * @property {string} [warning]
- */
-
-/**
- * Check if PID is currently alive on current system.
- * @param {number} pid
- * @returns {boolean}
- */
-function isPidAlive(pid) {
-  if (!pid || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err.code === "EPERM"; // EPERM means process exists but we lack permission to signal
-  }
-}
-
-/**
- * Build immutable SwarmSnapshot probing active worker slots.
- * @param {string} root
- * @param {Object} [options]
- * @param {boolean} [options.sampleResources=false]
- * @returns {Promise<{ slots: SwarmSlot[], warnings: string[], revision: string }>}
- */
-export async function buildSwarmSnapshot(root, _options = {}) {
-  const repoRoot = resolve(root || process.cwd());
-  const swarmDir = join(repoRoot, ".agent", "state", "swarm");
-  const warnings = [];
-  /** @type {SwarmSlot[]} */
-  const slots = [];
-
-  // Default 4 concurrency slots if no swarm config files exist
-  const defaultSlotIds = ["slot-01", "slot-02", "slot-03", "slot-04"];
-
-  if (existsSync(swarmDir)) {
-    try {
-      const slotFiles = readdirSync(swarmDir).filter((f) => f.startsWith("slot-") && f.endsWith(".json"));
-      for (const file of slotFiles) {
-        const slotPath = join(swarmDir, file);
-        try {
-          const content = readFileSync(slotPath, "utf-8");
-          /** @type {SwarmSlot} */
-          const slotData = JSON.parse(content);
-
-          let state = slotData.state || "idle";
-          let warning = slotData.warning;
-
-          if (slotData.pid && (state === "running" || state === "verifying")) {
-            if (!isPidAlive(slotData.pid)) {
-              state = "stale";
-              warning = `Process PID ${slotData.pid} is no longer alive`;
-              warnings.push(`Slot ${slotData.id} has dead PID ${slotData.pid}`);
-            }
-          }
-
-          slots.push({
-            id: slotData.id || file.replace(/\.json$/, ""),
-            state,
-            taskId: slotData.taskId,
-            attempt: slotData.attempt,
-            worktree: slotData.worktree,
-            branch: slotData.branch,
-            pid: slotData.pid,
-            processStartTime: slotData.processStartTime,
-            startedAt: slotData.startedAt,
-            durationMs: slotData.durationMs,
-            lockIds: slotData.lockIds || [],
-            writeScope: slotData.writeScope || [],
-            resourceSupport: "partial",
-            warning,
-          });
-        } catch (err) {
-          warnings.push(`Failed to parse slot file ${file}: ${err.message}`);
-        }
-      }
-    } catch (err) {
-      warnings.push(`Failed to read swarm state directory: ${err.message}`);
-    }
-  }
-
-  // Populate default idle slots if fewer than 4 slots exist
-  if (slots.length < 4) {
-    for (const defaultId of defaultSlotIds) {
-      if (!slots.some((s) => s.id === defaultId)) {
-        slots.push({
-          id: defaultId,
-          state: "idle",
-          lockIds: [],
-          writeScope: [],
-          resourceSupport: "partial",
-        });
-      }
-    }
-  }
-
-  slots.sort((a, b) => a.id.localeCompare(b.id));
-
-  const revisionPayload = JSON.stringify({ slots: slots.map((s) => ({ id: s.id, state: s.state, pid: s.pid })) });
-  const revision = "sha256:" + createHash("sha256").update(revisionPayload).digest("hex");
-
-  return { slots, warnings, revision };
-}
-
-/**
- * Swarm state reducer for updating view navigation state.
- * @param {Record<string, any>} state
- * @param {import("../key-decoder.mjs").KeyEvent | { type: string, payload?: any }} event
- * @returns {Record<string, any>}
- */
-export function reduceSwarmState(state, event) {
-  const nextState = { ...state };
-  if (!event) return nextState;
-
-  if (typeof event === "object" && "type" in event) {
-    if (event.type === "SELECT_SLOT") {
-      nextState.selectedSlotId = String(event.payload || "");
-    }
-  }
-
-  return nextState;
-}

package/src/ux/terminal-session.mjs

@@ -1,215 +0,0 @@
-import { detectTerminalCapabilities } from "./capabilities.mjs";
-import { createKeyDecoder } from "./key-decoder.mjs";
-
-export class WizardCancelledError extends Error {
-  /**
-   * @param {string} [message]
-   * @param {"escape" | "ctrl-c" | "quit" | "stream-closed"} [reason="ctrl-c"]
-   */
-  constructor(message = "Wizard operation cancelled by user", reason = "ctrl-c") {
-    super(message);
-    this.name = "WizardCancelledError";
-    this.code = 130;
-    this.reason = reason;
-  }
-}
-
-/**
- * @typedef {import("./capabilities.mjs").TerminalCapabilities} TerminalCapabilities
- * @typedef {import("./capabilities.mjs").TerminalSessionOptions} TerminalSessionOptions
- * @typedef {import("./key-decoder.mjs").KeyEvent} KeyEvent
- * @typedef {import("./renderer.mjs").RenderFrame} RenderFrame
- */
-
-/**
- * @typedef {Object} TerminalSession
- * @property {TerminalCapabilities} capabilities
- * @property {() => Promise<void>} enter
- * @property {(frame: RenderFrame) => Promise<void>} render
- * @property {<T>(operation: () => Promise<T>) => Promise<T>} suspend
- * @property {() => Promise<void>} restore
- * @property {() => Promise<void>} close
- * @property {(listener: (key: KeyEvent) => void) => () => void} onKey
- * @property {(listener: (size: { columns: number, rows: number }) => void) => () => void} onResize
- */
-
-/**
- * Create terminal raw-mode session manager.
- * @param {TerminalSessionOptions} [options]
- * @returns {TerminalSession}
- */
-export function createTerminalSession(options = {}) {
-  const input = options.input || process.stdin;
-  const output = options.output || process.stdout;
-
-  const capabilities = detectTerminalCapabilities(options);
-  const keyDecoder = createKeyDecoder();
-
-  let isEntered = false;
-  let isClosed = false;
-  let wasRaw = Boolean(input && input.isRaw);
-
-  const keyListeners = new Set();
-  const resizeListeners = new Set();
-
-  let winchScheduled = false;
-
-  const handleData = (chunk) => {
-    if (isClosed) return;
-    const events = keyDecoder.push(chunk);
-    for (const event of events) {
-      if (event.name === "ctrl-c") {
-        session.close().catch(() => {});
-        throw new WizardCancelledError("Wizard operation cancelled by user (SIGINT).", "ctrl-c");
-      }
-      for (const listener of keyListeners) {
-        try {
-          listener(event);
-        } catch (err) {
-          if (err instanceof WizardCancelledError) {
-            session.close().catch(() => {});
-            throw err;
-          }
-        }
-      }
-    }
-  };
-
-  const handleSigwinch = () => {
-    if (winchScheduled || isClosed) return;
-    winchScheduled = true;
-    queueMicrotask(() => {
-      winchScheduled = false;
-      if (isClosed) return;
-      capabilities.columns = Math.max(10, output.columns || input.columns || process.stdout.columns || 80);
-      capabilities.rows = Math.max(5, output.rows || input.rows || process.stdout.rows || 24);
-      for (const listener of resizeListeners) {
-        listener({ columns: capabilities.columns, rows: capabilities.rows });
-      }
-    });
-  };
-
-  const handleSigint = () => {
-    session.close().catch(() => {});
-    throw new WizardCancelledError("Wizard operation cancelled by user (SIGINT).", "ctrl-c");
-  };
-
-  const session = {
-    capabilities,
-
-    async enter() {
-      if (isEntered || isClosed) return;
-      isEntered = true;
-
-      if (capabilities.inputIsTTY && typeof input.setRawMode === "function") {
-        wasRaw = Boolean(input.isRaw);
-        input.setRawMode(true);
-        input.resume();
-        if (typeof input.setEncoding === "function") {
-          input.setEncoding("utf-8");
-        }
-      }
-
-      if (capabilities.ansi && capabilities.outputIsTTY) {
-        if (capabilities.alternateScreen) {
-          output.write("\u001b[?1049h"); // Enter alternate screen
-        }
-        output.write("\u001b[?25l"); // Hide cursor
-      }
-
-      input.on("data", handleData);
-      process.on("SIGWINCH", handleSigwinch);
-      process.on("SIGINT", handleSigint);
-    },
-
-    async render(frame) {
-      if (isClosed || !capabilities.ansi) return;
-      // Delegated to renderer ANSI builder
-      const { renderFrameToAnsi } = await import("./renderer.mjs");
-      const ansiText = renderFrameToAnsi(frame, capabilities);
-      output.write(ansiText);
-    },
-
-    async suspend(operation) {
-      if (!isEntered || isClosed) return operation();
-
-      // Temporarily restore cooked mode
-      input.removeListener("data", handleData);
-      process.removeListener("SIGWINCH", handleSigwinch);
-      process.removeListener("SIGINT", handleSigint);
-
-      if (capabilities.ansi && capabilities.outputIsTTY) {
-        output.write("\u001b[?25h"); // Show cursor
-        if (capabilities.alternateScreen) {
-          output.write("\u001b[?1049l"); // Leave alternate screen
-        }
-      }
-
-      if (capabilities.inputIsTTY && typeof input.setRawMode === "function") {
-        input.setRawMode(wasRaw);
-      }
-
-      try {
-        return await operation();
-      } finally {
-        // Re-enter raw mode
-        if (capabilities.inputIsTTY && typeof input.setRawMode === "function") {
-          input.setRawMode(true);
-        }
-        if (capabilities.ansi && capabilities.outputIsTTY) {
-          if (capabilities.alternateScreen) {
-            output.write("\u001b[?1049h");
-          }
-          output.write("\u001b[?25l");
-        }
-        input.on("data", handleData);
-        process.on("SIGWINCH", handleSigwinch);
-        process.on("SIGINT", handleSigint);
-      }
-    },
-
-    async restore() {
-      await session.close();
-    },
-
-    async close() {
-      if (isClosed) return;
-      isClosed = true;
-      isEntered = false;
-
-      input.removeListener("data", handleData);
-      process.removeListener("SIGWINCH", handleSigwinch);
-      process.removeListener("SIGINT", handleSigint);
-
-      if (capabilities.ansi && capabilities.outputIsTTY) {
-        output.write("\u001b[?25h"); // Show cursor
-        if (capabilities.alternateScreen) {
-          output.write("\u001b[?1049l"); // Leave alternate screen
-        }
-      }
-
-      if (capabilities.inputIsTTY && typeof input.setRawMode === "function") {
-        try {
-          input.setRawMode(wasRaw);
-        } catch {
-          // Ignore state restoration failures on teardown
-        }
-      }
-
-      keyListeners.clear();
-      resizeListeners.clear();
-    },
-
-    onKey(listener) {
-      keyListeners.add(listener);
-      return () => keyListeners.delete(listener);
-    },
-
-    onResize(listener) {
-      resizeListeners.add(listener);
-      return () => resizeListeners.delete(listener);
-    },
-  };
-
-  return session;
-}

package/src/ux/widgets.mjs

@@ -1,323 +0,0 @@
-import { getStringWidth, clipText } from "./layout.mjs";
-import { getSymbols } from "./capabilities.mjs";
-
-/**
- * Filter items by string filter using token subsequence matching.
- * @template T
- * @param {T[]} items
- * @param {string} filterText
- * @param {(item: T) => string} getText
- * @returns {T[]}
- */
-export function filterItems(items, filterText, getText) {
-  if (!filterText || !filterText.trim()) return items;
-  const tokens = filterText.trim().toLowerCase().split(/\s+/);
-
-  return items.filter((item) => {
-    const text = getText(item).toLowerCase();
-    return tokens.every((token) => text.includes(token));
-  });
-}
-
-/**
- * Create list widget state and reducers.
- * @template T
- * @param {Object} opts
- * @param {T[]} opts.items
- * @param {(item: T) => string} opts.getId
- * @param {(item: T) => string} opts.getText
- * @param {number} [opts.pageSize=10]
- * @param {boolean} [opts.multiSelect=false]
- */
-export function createListState(opts) {
-  const { items, getId, getText, pageSize = 10, multiSelect = false } = opts;
-
-  let filter = "";
-  let selectedIndex = 0;
-  let offset = 0;
-  const selectedIds = new Set();
-
-  function getFilteredItems() {
-    return filterItems(items, filter, getText);
-  }
-
-  function clampSelection() {
-    const filtered = getFilteredItems();
-    if (filtered.length === 0) {
-      selectedIndex = 0;
-      offset = 0;
-      return;
-    }
-    if (selectedIndex < 0) selectedIndex = 0;
-    if (selectedIndex >= filtered.length) selectedIndex = filtered.length - 1;
-
-    // Adjust scroll offset viewport
-    if (selectedIndex < offset) {
-      offset = selectedIndex;
-    } else if (selectedIndex >= offset + pageSize) {
-      offset = selectedIndex - pageSize + 1;
-    }
-  }
-
-  clampSelection();
-
-  return {
-    get filter() {
-      return filter;
-    },
-    set filter(val) {
-      filter = val;
-      selectedIndex = 0;
-      offset = 0;
-      clampSelection();
-    },
-    get selectedIndex() {
-      return selectedIndex;
-    },
-    get offset() {
-      return offset;
-    },
-    get selectedIds() {
-      return Array.from(selectedIds);
-    },
-
-    setItems(newItems) {
-      opts.items = newItems;
-      clampSelection();
-    },
-
-    move(delta) {
-      const filtered = getFilteredItems();
-      if (filtered.length === 0) return;
-      selectedIndex += delta;
-      clampSelection();
-    },
-
-    page(direction) {
-      const step = Math.max(1, pageSize - 2);
-      this.move(direction * step);
-    },
-
-    toStart() {
-      selectedIndex = 0;
-      clampSelection();
-    },
-
-    toEnd() {
-      const filtered = getFilteredItems();
-      selectedIndex = Math.max(0, filtered.length - 1);
-      clampSelection();
-    },
-
-    toggleCurrent() {
-      if (!multiSelect) return;
-      const filtered = getFilteredItems();
-      const current = filtered[selectedIndex];
-      if (!current) return;
-      const id = getId(current);
-      if (selectedIds.has(id)) {
-        selectedIds.delete(id);
-      } else {
-        selectedIds.add(id);
-      }
-    },
-
-    selectAll() {
-      if (!multiSelect) return;
-      for (const item of getFilteredItems()) {
-        selectedIds.add(getId(item));
-      }
-    },
-
-    clearSelection() {
-      selectedIds.clear();
-    },
-
-    getSelectedItem() {
-      const filtered = getFilteredItems();
-      return filtered[selectedIndex] || null;
-    },
-
-    getFilteredItems,
-    getId,
-    getText,
-    pageSize,
-    multiSelect,
-  };
-}
-
-/**
- * Render paginated list lines.
- * @template T
- * @param {ReturnType<typeof createListState<T>>} state
- * @param {import("./layout.mjs").computeResponsiveLayout extends (...args: any[]) => infer R ? R : never} layout
- * @param {import("./capabilities.mjs").TerminalCapabilities} caps
- * @returns {import("./renderer.mjs").ScreenLine[]}
- */
-export function renderListLines(state, layout, caps) {
-  const symbols = getSymbols(caps);
-  const filtered = state.getFilteredItems();
-  const lines = [];
-
-  const total = filtered.length;
-  const startIdx = state.offset;
-  const endIdx = Math.min(total, startIdx + state.pageSize);
-
-  // Scroll indicator top
-  if (startIdx > 0) {
-    const aboveCount = startIdx;
-    lines.push({
-      runs: [
-        {
-          text: `${symbols.arrowUp} ${aboveCount} more items above`,
-          style: { fg: "cyan", dim: true },
-        },
-      ],
-    });
-  }
-
-  for (let i = startIdx; i < endIdx; i++) {
-    const item = filtered[i];
-    const isSelected = i === state.selectedIndex;
-    const itemText = state.getText(item);
-    const itemId = state.getId(item);
-    const isChecked = state.selectedIds.includes(itemId);
-
-    let prefix = "  ";
-    if (state.multiSelect) {
-      prefix = isChecked ? `${symbols.checked} ` : `${symbols.unchecked} `;
-    }
-
-    let pointer = isSelected ? `${symbols.select} ` : "  ";
-    let lineText = `${pointer}${prefix}${itemText}`;
-
-    /** @type {import("./renderer.mjs").TextStyle} */
-    let style = { fg: "default" };
-    if (isSelected) {
-      style = { fg: "cyan", bold: true };
-    }
-
-    lines.push({
-      runs: [{ text: clipText(lineText, layout.mainWidth || layout.width), style }],
-    });
-  }
-
-  // Scroll indicator bottom
-  if (endIdx < total) {
-    const belowCount = total - endIdx;
-    lines.push({
-      runs: [
-        {
-          text: `${symbols.arrowDown} ${belowCount} more items below`,
-          style: { fg: "cyan", dim: true },
-        },
-      ],
-    });
-  }
-
-  return lines;
-}
-
-/**
- * Create text input state and cursor manager.
- * @param {Object} [opts]
- * @param {string} [opts.initialValue=""]
- * @param {boolean} [opts.secret=false]
- */
-export function createTextInputState(opts = {}) {
-  let value = opts.initialValue || "";
-  let cursor = value.length;
-  let visible = !opts.secret;
-
-  return {
-    get value() {
-      return value;
-    },
-    set value(v) {
-      value = String(v);
-      cursor = value.length;
-    },
-    get cursor() {
-      return cursor;
-    },
-    get visible() {
-      return visible;
-    },
-    toggleVisible() {
-      visible = !visible;
-    },
-
-    insert(text) {
-      if (!text) return;
-      value = value.slice(0, cursor) + text + value.slice(cursor);
-      cursor += text.length;
-    },
-
-    backspace() {
-      if (cursor > 0) {
-        value = value.slice(0, cursor - 1) + value.slice(cursor);
-        cursor--;
-      }
-    },
-
-    delete() {
-      if (cursor < value.length) {
-        value = value.slice(0, cursor) + value.slice(cursor + 1);
-      }
-    },
-
-    moveLeft() {
-      if (cursor > 0) cursor--;
-    },
-
-    moveRight() {
-      if (cursor < value.length) cursor++;
-    },
-
-    toStart() {
-      cursor = 0;
-    },
-
-    toEnd() {
-      cursor = value.length;
-    },
-
-    clear() {
-      value = "";
-      cursor = 0;
-    },
-
-    getDisplayValue(caps) {
-      if (!visible && opts.secret) {
-        const maskChar = caps.unicode ? "•" : "*";
-        return maskChar.repeat(value.length);
-      }
-      return value;
-    },
-  };
-}
-
-/**
- * Render sticky status bar footer.
- * @param {Array<{ key: string, label: string }>} bindings
- * @param {number} width
- * @param {import("./capabilities.mjs").TerminalCapabilities} caps
- * @returns {import("./renderer.mjs").ScreenLine}
- */
-export function renderStatusBar(bindings, width, _caps) {
-  const runs = [];
-  let currentWidth = 0;
-
-  for (const b of bindings) {
-    const itemStr = `${b.key} ${b.label}  `;
-    const itemWidth = getStringWidth(itemStr);
-
-    if (currentWidth + itemWidth > width) break;
-
-    runs.push({ text: `${b.key} `, style: { fg: "cyan", bold: true } });
-    runs.push({ text: `${b.label}  `, style: { fg: "white", dim: true } });
-    currentWidth += itemWidth;
-  }
-
-  return { runs };
-}