pi-orchestrator-config 4.1.5

package/extensions/orchestrator/async-wait.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared helper for waiting on async result files.
+ * Extracted so it can be tested without loading the full async-agents module.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Wait up to deadlineMs for result files to appear.
+ * Uses a single group-level deadline (not per-file).
+ */
+export async function waitForResultFiles(
+  resultDir: string,
+  jobIds: string[],
+  deadlineMs: number,
+): Promise<Set<string>> {
+  const found = new Set<string>();
+  const deadline = Date.now() + deadlineMs;
+  // Always scan at least once (handles deadlineMs=0)
+  do {
+    let allFound = true;
+    for (const id of jobIds) {
+      if (found.has(id)) continue;
+      if (existsSync(join(resultDir, `${id}.json`))) {
+        found.add(id);
+      } else {
+        allFound = false;
+      }
+    }
+    if (allFound) break;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    await new Promise(r => setTimeout(r, Math.min(250, remaining)));
+  } while (Date.now() < deadline);
+  return found;
+}

package/extensions/orchestrator/btw.ts

@@ -0,0 +1,210 @@
+/**
+ * /btw command — quick side questions without polluting conversation history.
+ */
+
+import { complete, type UserMessage } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { tryGetSystemPromptOptions } from "./utils.js";
+import {
+  BorderedLoader,
+  convertToLlm,
+  serializeConversation,
+} from "@earendil-works/pi-coding-agent";
+import {
+  Key,
+  matchesKey,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+
+export function registerBtw(pi: ExtensionAPI): void {
+  pi.registerCommand("btw", {
+    description: "Ask a quick side question without polluting conversation history",
+    handler: async (args, ctx) => {
+      const question = args?.trim();
+      if (!question) {
+        if (ctx.hasUI) ctx.ui.notify("Usage: /btw <question>", "error");
+        return;
+      }
+
+      if (!ctx.model) {
+        if (ctx.hasUI) ctx.ui.notify("No model selected. Use /model to select one first.", "error");
+        return;
+      }
+
+      // Build conversation context
+      const branch = ctx.sessionManager.getBranch();
+      const messages = branch
+        .filter((e: any) => e.type === "message")
+        .map((e: any) => e.message);
+      let conversationText = "";
+      if (messages.length > 0) {
+        const llmMessages = convertToLlm(messages);
+        conversationText = serializeConversation(llmMessages);
+      }
+
+      // Build context-aware system prompt using loaded resources
+      let projectContext = "";
+      const opts = tryGetSystemPromptOptions(ctx);
+      if (opts?.contextFiles?.length) {
+        const names = opts.contextFiles.map((f: any) => f.path?.split("/").pop() || f.path || "(unknown)").join(", ");
+        projectContext = `\n- Project context files loaded: ${names}`;
+      }
+      if (opts?.skills?.length) {
+        const names = opts.skills.map((s: any) => s.name || s).join(", ");
+        projectContext += `\n- Available skills: ${names}`;
+      }
+
+      const systemPrompt = `You are answering a quick "by the way" side question during a coding session.
+
+Rules:
+- Answer concisely and directly based on the conversation context provided.
+- You have NO tool access — you cannot read files, run commands, or make changes.
+- Only answer based on the conversation and loaded project context.${projectContext}
+- Keep your response brief and to the point.
+- Use markdown formatting where helpful (code blocks, lists, bold).
+- If the conversation context doesn't contain enough information to answer, say so honestly.`;
+
+      const userMessage: UserMessage = {
+        role: "user",
+        content: [{
+          type: "text",
+          text: `<conversation_context>\n${conversationText}\n</conversation_context>\n\n<side_question>\n${question}\n</side_question>\n\nAnswer the side question above based on the conversation context. Be concise.`,
+        }],
+        timestamp: Date.now(),
+      };
+
+      // Step 1: Get the answer with a loading spinner
+      const answerResult = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
+        const loader = new BorderedLoader(tui, theme, `Thinking (${ctx.model!.id})...`);
+        loader.onAbort = () => done(null);
+
+        const doQuery = async () => {
+          const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model!);
+          if (!auth.ok || !auth.apiKey) {
+            throw new Error(auth.ok ? `No API key for ${ctx.model!.provider}` : auth.error);
+          }
+          const response = await complete(
+            ctx.model!,
+            { systemPrompt, messages: [userMessage] },
+            { apiKey: auth.apiKey, headers: auth.headers, signal: loader.signal },
+          );
+          if (response.stopReason === "aborted") return null;
+          if (response.stopReason === "error") return null;
+          return response.content
+            .filter((c: any) => c.type === "text" && typeof c.text === "string")
+            .map((c: any) => c.text)
+            .join("\n");
+        };
+
+        doQuery().then(done).catch(() => done(null));
+        return loader;
+      });
+
+      if (answerResult === null) {
+        ctx.ui.notify("Cancelled", "info");
+        return;
+      }
+      if (answerResult.trim() === "") {
+        ctx.ui.notify("No answer received", "warning");
+        return;
+      }
+
+      // Step 2: Show answer in a scrollable overlay
+      await ctx.ui.custom<void>((tui, theme, _kb, done) => {
+        let scrollOffset = 0;
+        let cachedWidth: number | undefined;
+        let cachedLines: string[] | undefined;
+
+        return {
+          handleInput(data: string) {
+            if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c")) || data === " " || data.toLowerCase() === "q") {
+              done(undefined);
+              return;
+            }
+            if (matchesKey(data, Key.up) || data === "k") {
+              if (scrollOffset > 0) { scrollOffset--; cachedWidth = undefined; tui.requestRender(); }
+              return;
+            }
+            if (matchesKey(data, Key.down) || data === "j") {
+              scrollOffset++; cachedWidth = undefined; tui.requestRender();
+              return;
+            }
+            if (matchesKey(data, Key.pageUp)) {
+              scrollOffset = Math.max(0, scrollOffset - 10); cachedWidth = undefined; tui.requestRender();
+              return;
+            }
+            if (matchesKey(data, Key.pageDown)) {
+              scrollOffset += 10; cachedWidth = undefined; tui.requestRender();
+              return;
+            }
+          },
+
+          invalidate() { cachedWidth = undefined; cachedLines = undefined; },
+
+          render(width: number): string[] {
+            if (cachedLines && cachedWidth === width) return cachedLines;
+
+            const boxWidth = Math.min(width - 2, 120);
+            const contentWidth = boxWidth - 6;
+            const hLine = "─".repeat(boxWidth - 2);
+
+            const boxLine = (content: string, pad = 2): string => {
+              const padded = " ".repeat(pad) + content;
+              const right = Math.max(0, boxWidth - visibleWidth(padded) - 2);
+              return theme.fg("border", "│") + padded + " ".repeat(right) + theme.fg("border", "│");
+            };
+            const emptyLine = () => theme.fg("border", "│") + " ".repeat(boxWidth - 2) + theme.fg("border", "│");
+            const pad = (line: string) => { const len = visibleWidth(line); return line + " ".repeat(Math.max(0, width - len)); };
+
+            const lines: string[] = [];
+
+            // Header
+            lines.push(pad(theme.fg("accent", "╭" + hLine + "╮")));
+            lines.push(pad(boxLine(theme.fg("accent", theme.bold("btw")))));
+            lines.push(pad(theme.fg("accent", "├" + hLine + "┤")));
+
+            // Question
+            const qLabel = theme.fg("muted", "Q: ") + theme.fg("text", question);
+            for (const l of wrapTextWithAnsi(qLabel, contentWidth)) lines.push(pad(boxLine(l)));
+            lines.push(pad(emptyLine()));
+            lines.push(pad(theme.fg("border", "├" + hLine + "┤")));
+            lines.push(pad(emptyLine()));
+
+            // Answer lines
+            const answerLines: string[] = [];
+            for (const paragraph of answerResult.split("\n")) {
+              if (paragraph.trim() === "") { answerLines.push(""); }
+              else { answerLines.push(...wrapTextWithAnsi(paragraph, contentWidth)); }
+            }
+
+            // Scrolling
+            const termHeight = tui.height ?? 24;
+            const headerCount = lines.length;
+            const footerCount = 3;
+            const maxVisible = Math.max(1, termHeight - headerCount - footerCount - 2);
+            if (scrollOffset > Math.max(0, answerLines.length - maxVisible)) {
+              scrollOffset = Math.max(0, answerLines.length - maxVisible);
+            }
+            const visible = answerLines.slice(scrollOffset, scrollOffset + maxVisible);
+            for (const l of visible) lines.push(pad(boxLine(l)));
+
+            if (answerLines.length > maxVisible) {
+              const info = theme.fg("dim", `[${scrollOffset + 1}-${Math.min(scrollOffset + maxVisible, answerLines.length)}/${answerLines.length}]`);
+              lines.push(pad(boxLine(info)));
+            }
+
+            lines.push(pad(emptyLine()));
+            lines.push(pad(theme.fg("accent", "├" + hLine + "┤")));
+            lines.push(pad(boxLine(theme.fg("dim", "Esc/Space/q dismiss · ↑↓/j/k scroll · PgUp/PgDn"))));
+            lines.push(pad(theme.fg("accent", "╰" + hLine + "╯")));
+
+            cachedWidth = width;
+            cachedLines = lines;
+            return lines;
+          },
+        };
+      });
+    },
+  });
+}

package/extensions/orchestrator/cron-status-format.ts

@@ -0,0 +1,126 @@
+/**
+ * Pure cron status display helpers — no TUI deps (unit-testable).
+ */
+
+export interface CronStatusTaskView {
+  /** Unique overlay row id (e.g. "1" or "cron-123-abc.json:1"). */
+  id: string;
+  /** Numeric cron task id within its session file. */
+  taskId: number;
+  description: string;
+  task: string;
+  intervalMs?: number;
+  atHour?: number;
+  atMinute?: number;
+  createdAt: number;
+  lastRun?: number;
+  nextRun?: number;
+  /** Shown in list-all rows (e.g. "this session", "PID 42"). */
+  sessionLabel?: string;
+  isLocal?: boolean;
+  cronFile?: string;
+}
+
+export function formatCronSchedule(task: {
+  intervalMs?: number;
+  atHour?: number;
+  atMinute?: number;
+}): string {
+  if (task.intervalMs) {
+    if (task.intervalMs < 60000) return `every ${Math.round(task.intervalMs / 1000)}s`;
+    if (task.intervalMs < 3600000) {
+      return `every ${Math.round(task.intervalMs / 60000)}m`;
+    }
+    const h = Math.floor(task.intervalMs / 3600000);
+    const m = Math.round((task.intervalMs % 3600000) / 60000);
+    return m > 0 ? `every ${h}h${m}m` : `every ${h}h`;
+  }
+  if (task.atHour !== undefined && task.atMinute !== undefined) {
+    return `daily at ${String(task.atHour).padStart(2, "0")}:${String(task.atMinute).padStart(2, "0")}`;
+  }
+  return "unknown";
+}
+
+/** Best-effort next-fire timestamp for display. */
+export function resolveNextRunAt(
+  task: CronStatusTaskView,
+  now = Date.now(),
+): number | undefined {
+  if (task.nextRun != null) return task.nextRun;
+  if (task.intervalMs != null) {
+    if (task.lastRun != null) return task.lastRun + task.intervalMs;
+    return task.createdAt + task.intervalMs;
+  }
+  if (task.atHour !== undefined && task.atMinute !== undefined) {
+    const target = new Date(now);
+    target.setHours(task.atHour, task.atMinute, 0, 0);
+    if (target.getTime() <= now) target.setDate(target.getDate() + 1);
+    return target.getTime();
+  }
+  return undefined;
+}
+
+export function formatRelativeMs(ms: number): string {
+  const abs = Math.abs(ms);
+  if (abs < 60000) return `${Math.round(abs / 1000)}s`;
+  if (abs < 3600000) return `${Math.round(abs / 60000)}m`;
+  const h = Math.floor(abs / 3600000);
+  const m = Math.round((abs % 3600000) / 60000);
+  return m > 0 ? `${h}h${m}m` : `${h}h`;
+}
+
+export function formatLastRunLabel(
+  task: CronStatusTaskView,
+  now = Date.now(),
+): string {
+  if (task.lastRun == null) return "never";
+  return `${formatRelativeMs(now - task.lastRun)} ago`;
+}
+
+export function formatNextRunLabel(
+  task: CronStatusTaskView,
+  now = Date.now(),
+): string {
+  const at = resolveNextRunAt(task, now);
+  if (at == null) return "—";
+  const delta = at - now;
+  if (delta <= 0) return "soon";
+  return `in ${formatRelativeMs(delta)}`;
+}
+
+/** Map a CronTask-like object into an overlay row view. */
+export function toCronStatusTaskView(
+  task: {
+    id: number;
+    description: string;
+    task: string;
+    intervalMs?: number;
+    atHour?: number;
+    atMinute?: number;
+    createdAt: number;
+    lastRun?: number;
+    nextRun?: number;
+  },
+  opts: {
+    overlayId: string;
+    sessionLabel?: string;
+    isLocal?: boolean;
+    cronFile?: string;
+  },
+): CronStatusTaskView {
+  return {
+    id: opts.overlayId,
+    taskId: task.id,
+    description: task.description,
+    task: task.task,
+    intervalMs: task.intervalMs,
+    atHour: task.atHour,
+    atMinute: task.atMinute,
+    createdAt: task.createdAt,
+    lastRun: task.lastRun,
+    nextRun: task.nextRun,
+    sessionLabel: opts.sessionLabel,
+    isLocal: opts.isLocal,
+    cronFile: opts.cronFile,
+  };
+}

package/extensions/orchestrator/cron-status-ui.ts

@@ -0,0 +1,132 @@
+/**
+ * /cron list + list-all fullscreen overlay — list dashboard → task detail.
+ */
+
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+  formatCronSchedule,
+  formatLastRunLabel,
+  formatNextRunLabel,
+  type CronStatusTaskView,
+} from "./cron-status-format.js";
+import {
+  openListDetailOverlay,
+  OverlayScrollDetail,
+} from "./overlay-dashboard.js";
+
+export type { CronStatusTaskView } from "./cron-status-format.js";
+export {
+  formatCronSchedule,
+  formatLastRunLabel,
+  formatNextRunLabel,
+  resolveNextRunAt,
+  toCronStatusTaskView,
+} from "./cron-status-format.js";
+
+export interface CronStatusUiDeps {
+  listTasks: () => CronStatusTaskView[];
+  /** Remove by overlay row id. Return true if removed. */
+  removeTask: (id: string) => boolean;
+  title?: string;
+  emptyMessage?: string;
+  borderTitle?: (tasks: readonly CronStatusTaskView[]) => string;
+}
+
+/**
+ * Open fullscreen cron list. Loops list → detail until user closes list.
+ */
+export async function openCronStatusOverlay(
+  ctx: ExtensionCommandContext,
+  deps: CronStatusUiDeps,
+): Promise<void> {
+  const showSession = () =>
+    deps.listTasks().some((t) => !!t.sessionLabel);
+
+  await openListDetailOverlay(ctx, {
+    emptyMessage: deps.emptyMessage ?? "No scheduled tasks.",
+    listSpec: {
+      title: deps.title ?? "Cron tasks",
+      countLabel: (tasks) =>
+        `${tasks.length} task${tasks.length === 1 ? "" : "s"}`,
+      borderTitle:
+        deps.borderTitle ??
+        ((tasks) => `scheduled · ${tasks.length}`),
+      footerHints: "↑↓/jk select · Enter view · x remove · Esc close",
+      listItems: () => deps.listTasks(),
+      rowParts: (task, theme) => {
+        const now = Date.now();
+        const rightParts = [
+          theme.fg("muted", formatCronSchedule(task)),
+          theme.fg("dim", formatLastRunLabel(task, now)),
+          theme.fg("muted", formatNextRunLabel(task, now)),
+        ];
+        if (showSession() && task.sessionLabel) {
+          rightParts.unshift(theme.fg("dim", task.sessionLabel));
+        }
+        return {
+          glyph: theme.fg("warning", "■"),
+          title: task.description,
+          idLabel: theme.fg("dim", `#${task.taskId}`),
+          rightParts,
+        };
+      },
+      onX: (task) => {
+        deps.removeTask(task.id);
+      },
+    },
+    createDetail: (task, tui, theme, done) => {
+      const rowId = task.id;
+      return new OverlayScrollDetail(
+        tui,
+        theme,
+        {
+          footerHints: "↑↓/jk scroll · x remove · Esc back",
+          onX: () => deps.removeTask(rowId),
+          getHeader: (t) => {
+            const current = deps.listTasks().find((x) => x.id === rowId);
+            if (!current) return t.fg("error", "Task removed.");
+            const session = current.sessionLabel
+              ? t.fg("dim", ` · ${current.sessionLabel}`)
+              : "";
+            return (
+              `${t.fg("warning", "■")} ` +
+              t.fg(
+                "accent",
+                t.bold(`#${current.taskId} · ${current.description}`),
+              ) +
+              t.fg("muted", ` · ${formatCronSchedule(current)}`) +
+              session
+            );
+          },
+          getBodyLines: (t) => {
+            const current = deps.listTasks().find((x) => x.id === rowId);
+            if (!current) {
+              return [t.fg("error", "Task removed."), t.fg("dim", "Esc back")];
+            }
+            const now = Date.now();
+            const lines = [
+              `${t.fg("muted", "Schedule")}  ${formatCronSchedule(current)}`,
+              `${t.fg("muted", "Last run")}  ${formatLastRunLabel(current, now)}` +
+                (current.lastRun
+                  ? t.fg(
+                      "dim",
+                      ` · ${new Date(current.lastRun).toLocaleString()}`,
+                    )
+                  : ""),
+              `${t.fg("muted", "Next run")}  ${formatNextRunLabel(current, now)}`,
+              `${t.fg("muted", "Created")}   ${new Date(current.createdAt).toLocaleString()}`,
+            ];
+            if (current.sessionLabel) {
+              lines.push(
+                `${t.fg("muted", "Session")}  ${current.sessionLabel}`,
+              );
+            }
+            lines.push("", t.fg("muted", "Task"), current.task);
+            return lines;
+          },
+        },
+        done,
+      );
+    },
+  });
+}