@tt-a1i/openpi 0.1.0

package/extensions/cron/index.ts

@@ -0,0 +1,173 @@
+/**
+ * cron: user-scheduled prompts for this session.
+ *
+ * `/cron every 5m <prompt>` or `/cron in 30s <prompt>` queues a prompt that
+ * fires on a timer. Jobs live only in this session (in memory, cleared on
+ * shutdown) — deliberately no persisted config and no model tool: this is a
+ * user affordance, not something the agent schedules for itself.
+ *
+ * A job fires only when the session is idle, delivered the same way every
+ * other background completion is (followUp + triggerTurn), so it can never
+ * interrupt a streaming turn.
+ */
+
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  advanceDeliveredJobs,
+  dueJobs,
+  formatInterval,
+  parseCronCommand,
+  type CronJob,
+} from "./schedule.ts";
+
+/** How often the scheduler looks for due jobs. */
+const POLL_MS = 30_000;
+
+interface CronRuntime {
+  now(): number;
+  startPolling(tick: () => void): () => void;
+}
+
+const SYSTEM_RUNTIME: CronRuntime = {
+  now: Date.now,
+  startPolling(tick) {
+    const timer = setInterval(tick, POLL_MS);
+    // Never hold the process open for a scheduled prompt.
+    timer.unref?.();
+    return () => clearInterval(timer);
+  },
+};
+
+export default function cron(
+  pi: ExtensionAPI,
+  runtime: CronRuntime = SYSTEM_RUNTIME,
+) {
+  let jobs: CronJob[] = [];
+  let nextId = 1;
+  let stopPolling: (() => void) | undefined;
+  let context: ExtensionContext | undefined;
+
+  const stopTicker = () => {
+    stopPolling?.();
+    stopPolling = undefined;
+  };
+
+  const fire = (job: CronJob) => {
+    try {
+      pi.sendMessage(
+        {
+          customType: "cron-fire",
+          content: job.prompt,
+          display: true,
+          details: { id: job.id, recurring: job.intervalMs !== undefined },
+        },
+        { deliverAs: "followUp", triggerTurn: true },
+      );
+      return true;
+    } catch {
+      // Session may be shutting down; leave the job due for the next tick.
+      return false;
+    }
+  };
+
+  const tick = () => {
+    const ctx = context;
+    if (!ctx || jobs.length === 0) return;
+    // Only fire into an idle session: a followUp during a live turn would
+    // queue behind it anyway, and firing on a timer mid-stream is surprising.
+    if (!ctx.isIdle()) return;
+    const now = runtime.now();
+    const due = dueJobs(jobs, now);
+    if (due.length === 0) return;
+    const deliveredIds = new Set<number>();
+    for (const job of due) {
+      if (fire(job)) deliveredIds.add(job.id);
+    }
+    jobs = advanceDeliveredJobs(jobs, deliveredIds, now);
+    if (jobs.length === 0) stopTicker();
+  };
+
+  const startTicker = () => {
+    if (stopPolling) return;
+    stopPolling = runtime.startPolling(tick);
+  };
+
+  pi.registerCommand("cron", {
+    description:
+      "Schedule a prompt for this session (`/cron every 5m <prompt>`, `/cron in 30s <prompt>`, `/cron list`, `/cron remove <id>`)",
+    handler: async (rawArgs, ctx) => {
+      const parsed = parseCronCommand(rawArgs);
+
+      if (parsed.action === "help") {
+        ctx.ui.notify(
+          parsed.error ??
+            "Usage: /cron every <5m> <prompt> · /cron in <30s> <prompt> · /cron list · /cron remove <id>\nJobs live in this session only and fire when the session is idle.",
+          parsed.error ? "warning" : "info",
+        );
+        return;
+      }
+
+      if (parsed.action === "list") {
+        if (jobs.length === 0) {
+          ctx.ui.notify("No scheduled prompts in this session.", "info");
+          return;
+        }
+        const now = runtime.now();
+        const lines = jobs.map((job) => {
+          const inSeconds = Math.max(
+            0,
+            Math.round((job.nextRunAt - now) / 1000),
+          );
+          const when = job.intervalMs
+            ? `every ${formatInterval(job.intervalMs)}`
+            : "once";
+          return `${job.id}. ${when} · next in ${inSeconds}s · ${job.prompt}`;
+        });
+        ctx.ui.notify(lines.join("\n"), "info");
+        return;
+      }
+
+      if (parsed.action === "remove") {
+        const before = jobs.length;
+        jobs = jobs.filter((job) => job.id !== parsed.id);
+        if (jobs.length === 0) stopTicker();
+        ctx.ui.notify(
+          jobs.length === before
+            ? `No scheduled prompt with id ${parsed.id}.`
+            : `Removed scheduled prompt ${parsed.id}.`,
+          jobs.length === before ? "warning" : "info",
+        );
+        return;
+      }
+
+      const intervalMs = parsed.intervalMs!;
+      const job: CronJob = {
+        id: nextId++,
+        prompt: parsed.prompt!,
+        ...(parsed.oneShot ? {} : { intervalMs }),
+        nextRunAt: runtime.now() + intervalMs,
+      };
+      jobs.push(job);
+      startTicker();
+      ctx.ui.notify(
+        parsed.oneShot
+          ? `Scheduled prompt ${job.id} once in ${formatInterval(intervalMs)}.`
+          : `Scheduled prompt ${job.id} every ${formatInterval(intervalMs)}.`,
+        "info",
+      );
+    },
+  });
+
+  pi.on("session_start", (_event, ctx) => {
+    context = ctx;
+  });
+
+  pi.on("session_shutdown", () => {
+    stopTicker();
+    jobs = [];
+    context = undefined;
+  });
+}

package/extensions/cron/schedule.ts

@@ -0,0 +1,127 @@
+/**
+ * Pure scheduling logic for `/cron`. Kept free of timers, IO, and session
+ * state so the tricky parts — parsing, due-ness, and how a recurring job
+ * advances after a missed window — are directly testable.
+ */
+
+export interface CronJob {
+  readonly id: number;
+  /** Prompt delivered to the agent when the job fires. */
+  readonly prompt: string;
+  /** Milliseconds between runs; undefined for a one-shot job. */
+  readonly intervalMs?: number;
+  /** Absolute epoch ms of the next run. */
+  readonly nextRunAt: number;
+}
+
+const UNITS: Record<string, number> = {
+  s: 1_000,
+  m: 60_000,
+  h: 3_600_000,
+};
+
+export const MIN_INTERVAL_MS = 30_000;
+export const CRON_PROMPT_MAX_CHARS = 2_000;
+
+/**
+ * Parse a duration like `30s`, `5m`, `2h`. Deliberately a small duration
+ * grammar rather than crontab syntax: the ~30s poll cannot honor finer cron
+ * fields, so accepting them would promise precision that does not exist.
+ */
+export function parseDuration(text: string): number | undefined {
+  const match = /^(\d+)\s*([smh])$/i.exec(text.trim());
+  if (!match) return undefined;
+  const value = Number(match[1]);
+  if (!Number.isFinite(value) || value <= 0) return undefined;
+  return value * UNITS[match[2].toLowerCase()];
+}
+
+export interface ParsedCronCommand {
+  action: "add" | "list" | "remove" | "help";
+  /** add: every <duration> (recurring) or in <duration> (one-shot). */
+  intervalMs?: number;
+  oneShot?: boolean;
+  prompt?: string;
+  id?: number;
+  error?: string;
+}
+
+/**
+ * Parse `/cron` arguments:
+ *   every 5m <prompt>   recurring
+ *   in 30s <prompt>     one-shot
+ *   list | remove <id>  management
+ */
+export function parseCronCommand(raw: string): ParsedCronCommand {
+  const args = raw.trim();
+  if (!args || args === "help") return { action: "help" };
+  if (args === "list") return { action: "list" };
+
+  const remove = /^remove\s+(\d+)$/i.exec(args);
+  if (remove) return { action: "remove", id: Number(remove[1]) };
+
+  const schedule = /^(every|in)\s+(\S+)\s+([\s\S]+)$/i.exec(args);
+  if (!schedule) {
+    return {
+      action: "help",
+      error:
+        "Usage: /cron every <5m> <prompt> | in <30s> <prompt> | list | remove <id>",
+    };
+  }
+  const intervalMs = parseDuration(schedule[2]);
+  if (intervalMs === undefined) {
+    return {
+      action: "help",
+      error: `Could not read "${schedule[2]}" as a duration. Use 30s, 5m, or 2h.`,
+    };
+  }
+  if (intervalMs < MIN_INTERVAL_MS) {
+    return {
+      action: "help",
+      error: `Minimum interval is ${MIN_INTERVAL_MS / 1000}s (the scheduler polls about that often).`,
+    };
+  }
+  const prompt = schedule[3].trim().slice(0, CRON_PROMPT_MAX_CHARS);
+  if (!prompt) return { action: "help", error: "Provide a prompt to run." };
+  return {
+    action: "add",
+    intervalMs,
+    oneShot: schedule[1].toLowerCase() === "in",
+    prompt,
+  };
+}
+
+/** Jobs whose next run is at or before `now`. */
+export function dueJobs(jobs: readonly CronJob[], now: number) {
+  return jobs.filter((job) => job.nextRunAt <= now);
+}
+
+/** Advance only jobs whose prompt was successfully queued for delivery. */
+export function advanceDeliveredJobs(
+  jobs: readonly CronJob[],
+  deliveredIds: ReadonlySet<number>,
+  now: number,
+) {
+  return jobs.flatMap((job) => {
+    if (!deliveredIds.has(job.id)) return [job];
+    const next = advanceJob(job, now);
+    return next ? [next] : [];
+  });
+}
+
+/**
+ * Next state for a job that just fired: one-shots drop out, recurring jobs
+ * schedule from NOW rather than from the missed slot, so a long busy gap can
+ * never produce a burst of catch-up runs.
+ */
+export function advanceJob(job: CronJob, now: number): CronJob | undefined {
+  if (job.intervalMs === undefined) return undefined;
+  return { ...job, nextRunAt: now + job.intervalMs };
+}
+
+/** Human-readable duration for listings. */
+export function formatInterval(ms: number) {
+  if (ms % UNITS.h === 0) return `${ms / UNITS.h}h`;
+  if (ms % UNITS.m === 0) return `${ms / UNITS.m}m`;
+  return `${Math.round(ms / UNITS.s)}s`;
+}

package/extensions/file-mutation-display/index.ts

@@ -0,0 +1,105 @@
+import {
+  createBashToolDefinition,
+  createEditToolDefinition,
+  createWriteToolDefinition,
+  type ExtensionAPI,
+  type ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+import { loadSetupConfig } from "../shared/setup-config.ts";
+import {
+  compactBashRenderedComponent,
+  compactRenderedComponent,
+  singleLineRenderedComponent,
+} from "./render.ts";
+
+function withCompactCallRenderer(
+  definition: ToolDefinition<any, any, any>,
+): ToolDefinition<any, any, any> {
+  const renderCall = definition.renderCall;
+  if (!renderCall) return definition;
+  return {
+    ...definition,
+    renderCall(args, theme, context) {
+      const component = renderCall(args, theme, context);
+      if (
+        context.expanded ||
+        loadSetupConfig().ui.fileMutationDisplay === "full"
+      ) {
+        return component;
+      }
+      // While the model is still streaming a large Write/Edit payload, a
+      // syntax-highlighted preview changes on nearly every token and makes the
+      // entire tool block flash. Keep that phase to a stable one-line header;
+      // reveal the bounded preview once arguments are complete.
+      if (!context.argsComplete) {
+        return singleLineRenderedComponent(component, theme);
+      }
+      const background = context.isPartial
+        ? (text: string) => theme.bg("toolPendingBg", text)
+        : context.isError
+          ? (text: string) => theme.bg("toolErrorBg", text)
+          : (text: string) => theme.bg("toolSuccessBg", text);
+      return compactRenderedComponent(component, theme, undefined, background);
+    },
+  };
+}
+
+function withCompactBashRenderer(
+  definition: ToolDefinition<any, any, any>,
+): ToolDefinition<any, any, any> {
+  const renderCall = definition.renderCall;
+  const renderResult = definition.renderResult;
+  if (!renderCall || !renderResult) return definition;
+  return {
+    ...definition,
+    renderCall(args, theme, context) {
+      // A compact wrapper is not the native Text component expected through
+      // lastComponent, so rebuild the cheap call renderer on each update.
+      const component = renderCall(args, theme, {
+        ...context,
+        lastComponent: undefined,
+      });
+      if (context.expanded || loadSetupConfig().ui.bashToolDisplay === "full") {
+        return component;
+      }
+      return singleLineRenderedComponent(component, theme);
+    },
+    renderResult(result, options, theme, context) {
+      // Bash streams partial results. Never hand our wrapper back to Pi's
+      // native BashResultRenderComponent updater.
+      const component = renderResult(result, options, theme, {
+        ...context,
+        lastComponent: undefined,
+      });
+      if (options.expanded || loadSetupConfig().ui.bashToolDisplay === "full") {
+        return component;
+      }
+      return compactBashRenderedComponent(component, theme);
+    },
+  };
+}
+
+/**
+ * Override only the TUI renderers. The wrapped definitions are Pi's native
+ * Bash/Write/Edit tools, so schemas, execution, mutation queues, diffs, and
+ * errors stay on the upstream implementation.
+ */
+export default function fileMutationDisplay(pi: ExtensionAPI) {
+  pi.on("session_start", (_event, ctx) => {
+    const display = loadSetupConfig().ui;
+    if (ctx.mode === "tui") {
+      // Ctrl+O remains a temporary override. A new/reloaded session starts from
+      // the persisted defaults instead of inheriting an old expanded toggle.
+      ctx.ui.setToolsExpanded(
+        display.subagentResultDisplay === "full" &&
+          display.bashToolDisplay === "full" &&
+          display.fileMutationDisplay === "full",
+      );
+    }
+    pi.registerTool(withCompactBashRenderer(createBashToolDefinition(ctx.cwd)));
+    pi.registerTool(
+      withCompactCallRenderer(createWriteToolDefinition(ctx.cwd)),
+    );
+    pi.registerTool(withCompactCallRenderer(createEditToolDefinition(ctx.cwd)));
+  });
+}

package/extensions/file-mutation-display/render.ts

@@ -0,0 +1,107 @@
+import { stripVTControlCharacters } from "node:util";
+import { keyHint, type Theme } from "@earendil-works/pi-coding-agent";
+import {
+  truncateToWidth,
+  visibleWidth,
+  type Component,
+} from "@earendil-works/pi-tui";
+
+// Native Write/Edit renderings include their title and context rows. Three
+// visible rows keep the operation identifiable while making repeated file
+// mutations substantially quieter than Claude Code's default preview.
+export const FILE_MUTATION_PREVIEW_LINES = 3;
+export const BASH_OUTPUT_PREVIEW_LINES = 1;
+
+function expandHint(hidden: number) {
+  return `… ${hidden} more line${hidden === 1 ? "" : "s"} · ${keyHint("app.tools.expand", "to expand")}`;
+}
+
+/** Keep a long command identifiable without allowing it to wrap for many rows. */
+export function singleLineRenderedComponent(
+  component: Component,
+  theme: Theme,
+): Component {
+  return {
+    render(width) {
+      const lines = component.render(width);
+      if (lines.length <= 1) return lines;
+      if (width <= 2) return [truncateToWidth(lines[0] ?? "", width, "")];
+      return [
+        truncateToWidth(lines[0] ?? "", width - 2, "") + theme.fg("dim", " …"),
+      ];
+    },
+    invalidate() {
+      component.invalidate();
+    },
+  };
+}
+
+/** Preserve one output row, warnings, and final timing in compact Bash mode. */
+export function compactBashRenderedComponent(
+  component: Component,
+  theme: Theme,
+  maximum = BASH_OUTPUT_PREVIEW_LINES,
+): Component {
+  return {
+    render(width) {
+      const rendered = component.render(width);
+      const visible = rendered.filter(
+        (line) => stripVTControlCharacters(line).trim().length > 0,
+      );
+      let nativeHidden = 0;
+      const content: string[] = [];
+      const metadata: string[] = [];
+      let status: string | undefined;
+      for (const line of visible) {
+        const plain = stripVTControlCharacters(line).trim();
+        const hiddenMatch = plain.match(/\(?([0-9]+) earlier lines,/);
+        if (hiddenMatch) {
+          nativeHidden += Number(hiddenMatch[1]);
+        } else if (/^(Took|Elapsed)\s/.test(plain)) {
+          status = line;
+        } else if (/^\[(Full output|Truncated):/.test(plain)) {
+          metadata.push(line);
+        } else {
+          content.push(line);
+        }
+      }
+      const preview = content.slice(0, maximum);
+      const hidden =
+        nativeHidden + Math.max(0, content.length - preview.length);
+      return [
+        ...preview,
+        ...(hidden > 0 ? [theme.fg("dim", expandHint(hidden))] : []),
+        ...metadata,
+        ...(status ? [status] : []),
+      ];
+    },
+    invalidate() {
+      component.invalidate();
+    },
+  };
+}
+
+export function compactRenderedComponent(
+  component: Component,
+  theme: Theme,
+  maximum = FILE_MUTATION_PREVIEW_LINES,
+  background?: (text: string) => string,
+): Component {
+  return {
+    render(width) {
+      const lines = component.render(width);
+      if (lines.length <= maximum) return lines;
+      const hidden = lines.length - maximum;
+      const hint = theme.fg("dim", expandHint(hidden));
+      const paddedHint =
+        hint + " ".repeat(Math.max(0, width - visibleWidth(hint)));
+      return [
+        ...lines.slice(0, maximum),
+        background ? background(paddedHint) : hint,
+      ];
+    },
+    invalidate() {
+      component.invalidate();
+    },
+  };
+}