@bugabinga/pi-ext-llmiterate 0.1.0

package/rpc.ts

@@ -0,0 +1,228 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { RpcEvent } from "./types";
+
+const RPC_KILL_GRACE_MS = 5_000;
+const RESPONSE_EVENT = "response";
+const AGENT_END_EVENT = "agent_end";
+const CMD_NEW_SESSION = "new_session";
+const CMD_SET_SESSION_NAME = "set_session_name";
+const CMD_PROMPT = "prompt";
+const CMD_ABORT = "abort";
+
+interface PendingCommand {
+  command: string;
+  resolve(response: unknown): void;
+  reject(error: Error): void;
+}
+
+interface PiInvocation {
+  command: string;
+  args: string[];
+}
+
+interface RpcCommandPayload {
+  type: string;
+  [key: string]: unknown;
+}
+
+interface RpcResponse extends RpcWireEvent {
+  type: "response";
+  id?: unknown;
+  success?: unknown;
+  error?: unknown;
+  data?: unknown;
+}
+
+interface RpcWireEvent {
+  type: string;
+  [key: string]: unknown;
+}
+
+export interface RpcWorkerOptions {
+  cwd: string;
+  sessionDir: string;
+  onEvent(event: RpcEvent): void;
+  invocation?: PiInvocation;
+}
+
+export class PiRpcWorker {
+  private proc?: ChildProcessWithoutNullStreams;
+  private stdoutBuffer = "";
+  private stderr = "";
+  private nextId = 1;
+  private runningPrompt = false;
+  private readonly pending = new Map<string, PendingCommand>();
+  private currentPrompt?: { resolve(): void; reject(error: Error): void };
+
+  constructor(private readonly options: RpcWorkerOptions) {}
+
+  async runPrompt(prompt: string, sessionName: string): Promise<void> {
+    if (this.runningPrompt) throw new Error("RPC worker already has an active prompt");
+
+    this.runningPrompt = true;
+    try {
+      await this.command({ type: CMD_NEW_SESSION });
+      await this.command({ type: CMD_SET_SESSION_NAME, name: sessionName });
+
+      const done = new Promise<void>((resolve, reject) => {
+        this.currentPrompt = { resolve, reject };
+      });
+      await this.command({ type: CMD_PROMPT, message: prompt });
+      await done;
+    } finally {
+      this.runningPrompt = false;
+      this.currentPrompt = undefined;
+    }
+  }
+
+  abort(): void {
+    if (!this.proc || this.proc.killed) return;
+    void this.command({ type: CMD_ABORT }).catch(() => {});
+  }
+
+  dispose(): void {
+    const proc = this.proc;
+    this.proc = undefined;
+    this.rejectAll(new Error("RPC worker disposed"));
+    if (!proc || proc.killed) return;
+
+    let exited = false;
+    proc.once("exit", () => { exited = true; });
+    proc.kill("SIGTERM");
+    setTimeout(() => {
+      if (!exited) proc.kill("SIGKILL");
+    }, RPC_KILL_GRACE_MS).unref?.();
+  }
+
+  private ensureStarted(): void {
+    if (this.proc && !this.proc.killed) return;
+
+    fs.mkdirSync(this.options.sessionDir, { recursive: true });
+    const invocation = this.options.invocation ?? getPiInvocation([
+      "--mode", "rpc",
+      "--no-extensions",
+      "--session-dir", this.options.sessionDir,
+    ]);
+
+    this.stderr = "";
+    this.proc = spawn(invocation.command, invocation.args, {
+      cwd: this.options.cwd,
+      shell: false,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    this.proc.stdout.on("data", (data) => this.handleStdout(data.toString()));
+    this.proc.stderr.on("data", (data) => { this.stderr += data.toString(); });
+    this.proc.on("error", (error) => this.rejectAll(error));
+    this.proc.on("close", (code) => {
+      const message = this.stderr.trim() || `RPC worker exited with code ${code ?? "unknown"}`;
+      this.proc = undefined;
+      this.rejectAll(new Error(message));
+    });
+  }
+
+  private command(payload: RpcCommandPayload): Promise<unknown> {
+    this.ensureStarted();
+    if (!this.proc?.stdin.writable) return Promise.reject(new Error("RPC worker stdin closed"));
+
+    const id = `llmiterate-${this.nextId++}`;
+    const line = JSON.stringify({ id, ...payload }) + "\n";
+
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { command: payload.type, resolve, reject });
+      this.proc!.stdin.write(line, (error) => {
+        if (!error) return;
+        this.pending.delete(id);
+        reject(error);
+      });
+    });
+  }
+
+  private handleStdout(chunk: string): void {
+    this.stdoutBuffer += chunk;
+    const lines = this.stdoutBuffer.split("\n");
+    this.stdoutBuffer = lines.pop() ?? "";
+    for (const line of lines) this.handleLine(line);
+  }
+
+  private handleLine(line: string): void {
+    if (!line.trim()) return;
+
+    let event: RpcWireEvent;
+    try {
+      event = parseRpcObject(line);
+    } catch (error) {
+      this.failProtocol(errorMessage(error));
+      return;
+    }
+
+    if (isRpcResponse(event)) {
+      this.handleResponse(event);
+      return;
+    }
+
+    this.options.onEvent(event as RpcEvent);
+    if (event.type === AGENT_END_EVENT) this.currentPrompt?.resolve();
+  }
+
+  private handleResponse(response: RpcResponse): void {
+    const id = typeof response.id === "string" ? response.id : undefined;
+    if (!id) return;
+
+    const pending = this.pending.get(id);
+    if (!pending) return;
+    this.pending.delete(id);
+
+    if (response.success === false) {
+      const reason = response.error ?? `${pending.command} failed`;
+      pending.reject(new Error(String(reason)));
+      return;
+    }
+    pending.resolve(response.data ?? response);
+  }
+
+  private failProtocol(message: string): void {
+    this.proc?.kill("SIGTERM");
+    this.rejectAll(new Error(message));
+  }
+
+  private rejectAll(error: Error): void {
+    for (const pending of this.pending.values()) pending.reject(error);
+    this.pending.clear();
+    this.currentPrompt?.reject(error);
+    this.currentPrompt = undefined;
+    this.runningPrompt = false;
+  }
+}
+
+function parseRpcObject(line: string): RpcWireEvent {
+  const parsed = JSON.parse(line);
+  if (!isObject(parsed) || typeof parsed.type !== "string") throw new Error(`invalid RPC event: ${line}`);
+  return { ...parsed, type: parsed.type };
+}
+
+function isRpcResponse(event: RpcWireEvent): event is RpcResponse {
+  return event.type === RESPONSE_EVENT;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function getPiInvocation(args: string[]): PiInvocation {
+  const currentScript = process.argv[1];
+  const isBunVirtualScript = currentScript?.startsWith("/$bunfs/root/");
+  if (currentScript && !isBunVirtualScript && fs.existsSync(currentScript)) {
+    return { command: process.execPath, args: [currentScript, ...args] };
+  }
+
+  const execName = path.basename(process.execPath).toLowerCase();
+  const isGenericRuntime = /^(node|bun)(\.exe)?$/.test(execName);
+  return isGenericRuntime ? { command: "pi", args } : { command: process.execPath, args };
+}

package/types.ts

@@ -0,0 +1,45 @@
+import type { LlmiterateConfig, MarkerPrompt } from "./core";
+
+export type RunStatus = "queued" | "running" | "done" | "error";
+
+export interface LlmiterateRun {
+  id: number;
+  block: MarkerPrompt;
+  projectFile: string;
+  absoluteFile: string;
+  fullPrompt: string;
+  status: RunStatus;
+  queuedAt: number;
+  updatedAt: number;
+  assistantText: string;
+  toolText: string;
+  error?: string;
+}
+
+export interface UiState {
+  config?: LlmiterateConfig;
+  lockError?: string;
+  watchErrors: number;
+  activeRun?: LlmiterateRun;
+  queuedRuns: number;
+}
+
+export interface RpcTextPart {
+  type?: string;
+  text?: unknown;
+}
+
+export interface RpcMessage {
+  role?: string;
+  content?: string | RpcTextPart[];
+}
+
+export type RpcEvent =
+  | { type: "message_update" | "message_end"; message?: RpcMessage }
+  | { type: "tool_execution_start"; toolName?: unknown }
+  | { type: "tool_execution_end"; toolName?: unknown; isError?: unknown; result?: RpcToolResult }
+  | { type: "agent_end" };
+
+export interface RpcToolResult {
+  content?: RpcTextPart[];
+}

package/ui.ts

@@ -0,0 +1,103 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { Component } from "@earendil-works/pi-tui";
+import { previewText } from "./core";
+import type { LlmiterateRun, RunStatus, UiState } from "./types";
+
+const STATUS_KEY = "llmiterate";
+const WIDGET_KEY = "llmiterate";
+const WIDGET_RUN_LIMIT = 6;
+const PROMPT_PREVIEW_CHARS = 80;
+const DETAIL_PREVIEW_CHARS = 110;
+
+export function renderLlmiterateUi(
+  ctx: ExtensionContext | undefined,
+  panelVisible: boolean,
+  runs: readonly LlmiterateRun[],
+  state: UiState,
+): void {
+  if (!ctx?.hasUI) return;
+
+  ctx.ui.setStatus(STATUS_KEY, statusLine(ctx, state));
+  if (!panelVisible) {
+    ctx.ui.setWidget(WIDGET_KEY, undefined);
+    return;
+  }
+
+  ctx.ui.setWidget(WIDGET_KEY, (_tui, theme) => new LlmiterateWidget(runs, theme), {
+    placement: "belowEditor",
+  });
+}
+
+function statusLine(ctx: ExtensionContext, state: UiState): string {
+  const theme = ctx.ui.theme;
+  if (!state.config?.enabled) return theme.fg("dim", "llmiterate off");
+  if (state.lockError) return theme.fg("dim", "llmiterate standby");
+  if (state.watchErrors > 0) return theme.fg("warning", `llmiterate ${state.watchErrors} watch error(s)`);
+  if (state.activeRun) return theme.fg("accent", `llmiterate ${state.activeRun.status} ${state.activeRun.block.file}:${state.activeRun.block.startLine}`);
+  if (state.queuedRuns > 0) return theme.fg("warning", `llmiterate queued ${state.queuedRuns}`);
+  return theme.fg("dim", "llmiterate idle");
+}
+
+export class LlmiterateWidget implements Component {
+  constructor(
+    private readonly runs: readonly LlmiterateRun[],
+    private readonly theme: ExtensionContext["ui"]["theme"],
+  ) {}
+
+  render(width: number): string[] {
+    if (width <= 0) return [];
+
+    const inner = Math.max(1, width - 2);
+    const lines = [
+      this.border("╭", "╮", inner, ` ${this.theme.bold("llmiterate")} `),
+      ...this.runLines(inner),
+      this.border("╰", "╯", inner),
+    ];
+
+    return lines.map((line) => truncateToWidth(line, width, ""));
+  }
+
+  invalidate(): void {}
+
+  private runLines(inner: number): string[] {
+    if (this.runs.length === 0) return [this.line(this.theme.fg("dim", "no prompts queued yet"), inner)];
+
+    const lines: string[] = [];
+    for (const run of this.runs.slice(0, WIDGET_RUN_LIMIT)) {
+      lines.push(this.line(this.runHeader(run), inner));
+      if (run.toolText) lines.push(this.line(this.theme.fg("dim", `  ${run.toolText}`), inner));
+      if (run.error) lines.push(this.line(this.theme.fg("error", `  ${previewText(run.error, DETAIL_PREVIEW_CHARS)}`), inner));
+      else if (run.assistantText) lines.push(this.line(this.theme.fg("dim", `  ${previewText(run.assistantText, DETAIL_PREVIEW_CHARS)}`), inner));
+    }
+    return lines;
+  }
+
+  private runHeader(run: LlmiterateRun): string {
+    return `${statusIcon(run.status)} ${run.block.file}:${run.block.startLine} ${this.theme.fg("muted", run.block.marker)} ${previewText(run.block.prompt, PROMPT_PREVIEW_CHARS)}`;
+  }
+
+  private border(left: string, right: string, inner: number, label = ""): string {
+    const labelWidth = visibleWidth(label);
+    return this.theme.fg("border", left)
+      + this.theme.fg("accent", label)
+      + this.theme.fg("border", "─".repeat(Math.max(0, inner - labelWidth)) + right);
+  }
+
+  private line(text: string, inner: number): string {
+    const body = fit(text, inner);
+    return this.theme.fg("border", "│") + body + this.theme.fg("border", "│");
+  }
+}
+
+function fit(text: string, width: number): string {
+  const t = truncateToWidth(text, width, "…");
+  return t + " ".repeat(Math.max(0, width - visibleWidth(t)));
+}
+
+function statusIcon(status: RunStatus): string {
+  if (status === "queued") return "◌";
+  if (status === "running") return "●";
+  if (status === "done") return "✓";
+  return "✗";
+}

package/watcher.ts

@@ -0,0 +1,191 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  shouldIncludeCompiledPath,
+  shouldWatchDirectory,
+  toSlash,
+  type CompiledPathFilter,
+  type LlmiterateConfig,
+} from "./core";
+
+const DIRECTORY_REFRESH_MS = 250;
+
+type FileHandler = (absolutePath: string) => void;
+type ErrorHandler = () => void;
+
+export class ProjectWatcher {
+  private readonly watchers = new Map<string, fs.FSWatcher>();
+  private readonly fileTimers = new Map<string, ReturnType<typeof setTimeout>>();
+  private readonly dirTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+  public errorCount = 0;
+
+  constructor(
+    private readonly root: string,
+    private readonly config: LlmiterateConfig,
+    private readonly pathFilter: CompiledPathFilter,
+    private readonly onFileReady: FileHandler,
+    private readonly onError: ErrorHandler,
+  ) {}
+
+  start(): void {
+    if (!shouldWatchDirectory("", this.pathFilter)) return;
+
+    const root = path.resolve(this.root);
+    this.watchTree(root);
+    // fs.watch can miss changes made immediately after watcher creation.
+    // One delayed reconciliation makes startup deterministic without polling.
+    this.scheduleDirectoryRefresh(root);
+  }
+
+  stop(): void {
+    for (const timer of this.fileTimers.values()) clearTimeout(timer);
+    for (const timer of this.dirTimers.values()) clearTimeout(timer);
+    for (const watcher of this.watchers.values()) watcher.close();
+    this.fileTimers.clear();
+    this.dirTimers.clear();
+    this.watchers.clear();
+  }
+
+  scanAll(onFile: (absolutePath: string) => number): number {
+    let total = 0;
+    this.walkFiles(this.root, (file) => { total += onFile(file); });
+    return total;
+  }
+
+  private watchTree(dir: string): void {
+    const abs = path.resolve(dir);
+    if (this.watchers.has(abs)) return;
+
+    try {
+      const watcher = fs.watch(abs, { persistent: false }, (eventType, filename) => {
+        if (!filename) {
+          this.scheduleDirectoryRefresh(abs);
+          return;
+        }
+
+        this.handlePathEvent(path.join(abs, filename.toString()));
+        if (eventType === "rename") this.scheduleDirectoryRefresh(abs);
+      });
+      watcher.on("error", () => {
+        this.recordError();
+        this.unwatchTree(abs);
+      });
+      watcher.on("close", () => this.watchers.delete(abs));
+      this.watchers.set(abs, watcher);
+    } catch {
+      this.recordError();
+      // fs.watch is not equally reliable across platforms/runtimes. Still scan
+      // the directory once so startup/reconciliation catches already-written files.
+      this.refreshDirectory(abs);
+      return;
+    }
+
+    this.refreshDirectory(abs);
+  }
+
+  private handlePathEvent(absPath: string): void {
+    let stat: fs.Stats | undefined;
+    try { stat = fs.statSync(absPath); } catch { return; }
+
+    if (stat.isDirectory()) {
+      if (this.shouldWatchDir(absPath)) this.watchTree(absPath);
+      return;
+    }
+
+    if (stat.isFile()) this.scheduleFile(absPath);
+  }
+
+  private refreshDirectory(abs: string): void {
+    let entries: fs.Dirent[];
+    try { entries = fs.readdirSync(abs, { withFileTypes: true }); } catch { return; }
+
+    for (const entry of entries) {
+      const child = path.join(abs, entry.name);
+      const rel = this.projectRel(child);
+      if (entry.isDirectory()) {
+        if (!shouldWatchDirectory(rel, this.pathFilter)) continue;
+        this.watchTree(child);
+        continue;
+      }
+      if (entry.isFile() && shouldIncludeCompiledPath(rel, this.pathFilter)) this.scheduleFile(child);
+    }
+  }
+
+  private scheduleDirectoryRefresh(abs: string): void {
+    const existing = this.dirTimers.get(abs);
+    if (existing) clearTimeout(existing);
+    this.dirTimers.set(abs, setTimeout(() => {
+      this.dirTimers.delete(abs);
+      this.reconcileWatchers();
+      this.refreshDirectory(abs);
+    }, DIRECTORY_REFRESH_MS));
+  }
+
+  private reconcileWatchers(): void {
+    for (const dir of this.watchers.keys()) {
+      if (!fs.existsSync(dir)) this.unwatchTree(dir);
+    }
+  }
+
+  private unwatchTree(abs: string): void {
+    const watcher = this.watchers.get(abs);
+    this.watchers.delete(abs);
+    try { watcher?.close(); } catch {}
+
+    for (const dir of [...this.watchers.keys()]) {
+      if (isDescendant(abs, dir)) this.unwatchTree(dir);
+    }
+  }
+
+  private scheduleFile(absPath: string): void {
+    const rel = this.projectRel(absPath);
+    if (!isSafeProjectRel(rel) || !shouldIncludeCompiledPath(rel, this.pathFilter)) return;
+
+    const existing = this.fileTimers.get(rel);
+    if (existing) clearTimeout(existing);
+    this.fileTimers.set(rel, setTimeout(() => {
+      this.fileTimers.delete(rel);
+      this.onFileReady(absPath);
+    }, this.config.debounceMs));
+  }
+
+  private walkFiles(dir: string, onFile: FileHandler): void {
+    let entries: fs.Dirent[];
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+
+    for (const entry of entries) {
+      const abs = path.join(dir, entry.name);
+      const rel = this.projectRel(abs);
+      if (entry.isDirectory()) {
+        if (!shouldWatchDirectory(rel, this.pathFilter)) continue;
+        this.walkFiles(abs, onFile);
+        continue;
+      }
+      if (entry.isFile() && shouldIncludeCompiledPath(rel, this.pathFilter)) onFile(abs);
+    }
+  }
+
+  private projectRel(absPath: string): string {
+    return toSlash(path.relative(this.root, absPath));
+  }
+
+  private shouldWatchDir(absPath: string): boolean {
+    const rel = this.projectRel(absPath);
+    return isSafeProjectRel(rel) && shouldWatchDirectory(rel, this.pathFilter);
+  }
+
+  private recordError(): void {
+    this.errorCount++;
+    this.onError();
+  }
+}
+
+function isSafeProjectRel(rel: string): boolean {
+  return Boolean(rel) && !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+
+function isDescendant(parent: string, child: string): boolean {
+  const rel = path.relative(parent, child);
+  return Boolean(rel) && !rel.startsWith("..") && !path.isAbsolute(rel);
+}