@aliou/pi-processes 0.9.4 → 0.10.0

package/extensions/processes/tools/write/index.ts

@@ -0,0 +1,75 @@
+import type { ProcessManager } from "../../../../src/manager";
+import type { ProcessInfo } from "../../../../src/types";
+import type { ProcessesParamsType } from "../schema";
+
+export interface WriteDetails {
+  action: "write";
+  id: string;
+  processName: string;
+  process: ProcessInfo | null;
+  bytes: number;
+  end: boolean;
+  ok: boolean;
+  reason: string | null;
+}
+
+/**
+ * Write text to a running process's stdin.
+ *
+ * `input` defaults to an empty string so a caller can close stdin with
+ * `{ action: "write", id, end: true }` to signal EOF without writing anything.
+ */
+export function executeWrite(
+  params: ProcessesParamsType,
+  manager: ProcessManager,
+): WriteDetails {
+  if (!params.id) {
+    throw new Error("process write requires id");
+  }
+
+  const id = params.id;
+  const input = params.input ?? "";
+  const end = params.end ?? false;
+
+  if (input.length === 0 && !end) {
+    throw new Error(
+      'process write requires "input" or "end"; provide text to write or set end to close stdin',
+    );
+  }
+
+  const process = manager.get(id);
+  const result = manager.writeToStdin(id, input, { end });
+
+  if (result.ok) {
+    return {
+      action: "write",
+      id,
+      processName: process?.name ?? "(unknown)",
+      process,
+      bytes: Buffer.byteLength(input, "utf-8"),
+      end,
+      ok: true,
+      reason: null,
+    };
+  }
+
+  return {
+    action: "write",
+    id,
+    processName: process?.name ?? "(unknown)",
+    process,
+    bytes: 0,
+    end,
+    ok: false,
+    reason: result.reason,
+  };
+}
+
+export function formatWriteDetails(details: WriteDetails): string {
+  if (!details.ok) {
+    return `Failed to write to stdin for "${details.processName}" (${details.id}): ${details.reason}.`;
+  }
+
+  const suffix = details.end ? " and closed stdin" : "";
+  return `Wrote ${details.bytes} byte${details.bytes === 1 ? "" : "s"} to "${details.processName}" (${details.id})${suffix}.`;
+}

package/extensions/processes/tools/write/render.ts

@@ -0,0 +1,68 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Container, Text } from "@earendil-works/pi-tui";
+import { ProcessActionHeader } from "../components";
+import type { ProcessesParamsType } from "../schema";
+import { buildField } from "../utils";
+import type { WriteDetails } from ".";
+
+export function buildHeader(
+  args: ProcessesParamsType,
+  theme: Theme,
+  options?: { expanded?: boolean },
+): Container {
+  return new ProcessActionHeader(args, theme, {
+    action: "write",
+    expanded: options?.expanded,
+    suffix: args.id ? theme.fg("accent", `(${args.id})`) : undefined,
+  });
+}
+
+export function buildExpanded(details: WriteDetails, theme: Theme): Container {
+  const container = new Container();
+  container.addChild(buildSummary(details, theme));
+  return container;
+}
+
+export function buildCollapsed(details: WriteDetails, theme: Theme): Container {
+  const container = new Container();
+  container.addChild(buildSummary(details, theme));
+  return container;
+}
+
+export function buildFooter(
+  _details: WriteDetails,
+  _options: { expanded?: boolean },
+  _theme: Theme,
+): Container | null {
+  return null;
+}
+
+function buildSummary(details: WriteDetails, theme: Theme): Container {
+  const container = new Container();
+
+  if (!details.ok) {
+    container.addChild(
+      new Text(
+        theme.fg("error", `stdin write failed: ${details.reason ?? "unknown"}`),
+        0,
+        0,
+      ),
+    );
+    container.addChild(buildField("process", details.processName, theme));
+    return container;
+  }
+
+  const closeTag = details.end ? " (stdin closed)" : "";
+  container.addChild(
+    new Text(
+      theme.fg(
+        "muted",
+        `wrote ${details.bytes} byte${details.bytes === 1 ? "" : "s"}${closeTag}`,
+      ),
+      0,
+      0,
+    ),
+  );
+  container.addChild(buildField("process", details.processName, theme));
+  return container;
+}

package/extensions/processes/utils/truncate.ts

@@ -0,0 +1,285 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+export function truncateToWidth(
+  text: string,
+  maxWidth: number,
+  ellipsis = "…",
+  pad = false,
+): string {
+  if (maxWidth <= 0) return "";
+  if (text.length === 0) return pad ? " ".repeat(maxWidth) : "";
+
+  const ellipsisWidth = visibleWidth(ellipsis);
+  if (ellipsisWidth >= maxWidth) {
+    const textWidth = visibleWidth(text);
+    if (textWidth <= maxWidth) {
+      return pad ? text + " ".repeat(maxWidth - textWidth) : text;
+    }
+
+    const clippedEllipsis = truncateFragmentToWidth(ellipsis, maxWidth);
+    if (clippedEllipsis.width === 0) {
+      return pad ? " ".repeat(maxWidth) : "";
+    }
+
+    return finalizeTruncatedResult(
+      "",
+      0,
+      clippedEllipsis.text,
+      clippedEllipsis.width,
+      maxWidth,
+      pad,
+    );
+  }
+
+  if (isPrintableAscii(text)) {
+    if (text.length <= maxWidth) {
+      return pad ? text + " ".repeat(maxWidth - text.length) : text;
+    }
+
+    const targetWidth = maxWidth - ellipsisWidth;
+    return finalizeTruncatedResult(
+      text.slice(0, targetWidth),
+      targetWidth,
+      ellipsis,
+      ellipsisWidth,
+      maxWidth,
+      pad,
+    );
+  }
+
+  const targetWidth = maxWidth - ellipsisWidth;
+  let result = "";
+  let visibleSoFar = 0;
+  let keptWidth = 0;
+  let keepContiguousPrefix = true;
+  let overflowed = false;
+  let exhaustedInput = false;
+  const hasAnsi = text.includes("\u001b");
+  const hasTabs = text.includes("\t");
+
+  if (!hasAnsi && !hasTabs) {
+    for (const { segment } of segmenter.segment(text)) {
+      const width = visibleWidth(segment);
+      if (keepContiguousPrefix && keptWidth + width <= targetWidth) {
+        result += segment;
+        keptWidth += width;
+      } else {
+        keepContiguousPrefix = false;
+      }
+
+      visibleSoFar += width;
+      if (visibleSoFar > maxWidth) {
+        overflowed = true;
+        break;
+      }
+    }
+    exhaustedInput = !overflowed;
+  } else {
+    let index = 0;
+    let pendingAnsi = "";
+    while (index < text.length) {
+      const ansi = readAnsiSequence(text, index);
+      if (ansi) {
+        pendingAnsi += ansi;
+        index += ansi.length;
+        continue;
+      }
+
+      if (text[index] === "\t") {
+        if (keepContiguousPrefix && keptWidth + 3 <= targetWidth) {
+          if (pendingAnsi) {
+            result += pendingAnsi;
+            pendingAnsi = "";
+          }
+          result += "\t";
+          keptWidth += 3;
+        } else {
+          keepContiguousPrefix = false;
+          pendingAnsi = "";
+        }
+
+        visibleSoFar += 3;
+        if (visibleSoFar > maxWidth) {
+          overflowed = true;
+          break;
+        }
+        index++;
+        continue;
+      }
+
+      let end = index;
+      while (end < text.length && text[end] !== "\t") {
+        const nextAnsi = readAnsiSequence(text, end);
+        if (nextAnsi) break;
+        end++;
+      }
+
+      for (const { segment } of segmenter.segment(text.slice(index, end))) {
+        const width = visibleWidth(segment);
+        if (keepContiguousPrefix && keptWidth + width <= targetWidth) {
+          if (pendingAnsi) {
+            result += pendingAnsi;
+            pendingAnsi = "";
+          }
+          result += segment;
+          keptWidth += width;
+        } else {
+          keepContiguousPrefix = false;
+          pendingAnsi = "";
+        }
+
+        visibleSoFar += width;
+        if (visibleSoFar > maxWidth) {
+          overflowed = true;
+          break;
+        }
+      }
+
+      if (overflowed) break;
+      index = end;
+    }
+    exhaustedInput = index >= text.length;
+  }
+
+  if (!overflowed && exhaustedInput) {
+    return pad ? text + " ".repeat(Math.max(0, maxWidth - visibleSoFar)) : text;
+  }
+
+  return finalizeTruncatedResult(
+    result,
+    keptWidth,
+    ellipsis,
+    ellipsisWidth,
+    maxWidth,
+    pad,
+  );
+}
+
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+function isPrintableAscii(text: string): boolean {
+  for (let index = 0; index < text.length; index++) {
+    const code = text.charCodeAt(index);
+    if (code < 0x20 || code > 0x7e) return false;
+  }
+  return true;
+}
+
+function truncateFragmentToWidth(
+  text: string,
+  maxWidth: number,
+): { text: string; width: number } {
+  if (maxWidth <= 0 || text.length === 0) {
+    return { text: "", width: 0 };
+  }
+
+  if (isPrintableAscii(text)) {
+    const clipped = text.slice(0, maxWidth);
+    return { text: clipped, width: clipped.length };
+  }
+
+  const hasAnsi = text.includes("\u001b");
+  const hasTabs = text.includes("\t");
+  if (!hasAnsi && !hasTabs) {
+    let result = "";
+    let width = 0;
+
+    for (const { segment } of segmenter.segment(text)) {
+      const segmentWidth = visibleWidth(segment);
+      if (width + segmentWidth > maxWidth) break;
+      result += segment;
+      width += segmentWidth;
+    }
+
+    return { text: result, width };
+  }
+
+  let result = "";
+  let width = 0;
+  let index = 0;
+  let pendingAnsi = "";
+
+  while (index < text.length) {
+    const ansi = readAnsiSequence(text, index);
+    if (ansi) {
+      pendingAnsi += ansi;
+      index += ansi.length;
+      continue;
+    }
+
+    if (text[index] === "\t") {
+      if (width + 3 > maxWidth) break;
+      if (pendingAnsi) {
+        result += pendingAnsi;
+        pendingAnsi = "";
+      }
+      result += "\t";
+      width += 3;
+      index++;
+      continue;
+    }
+
+    let end = index;
+    while (end < text.length && text[end] !== "\t") {
+      const nextAnsi = readAnsiSequence(text, end);
+      if (nextAnsi) break;
+      end++;
+    }
+
+    for (const { segment } of segmenter.segment(text.slice(index, end))) {
+      const segmentWidth = visibleWidth(segment);
+      if (width + segmentWidth > maxWidth) {
+        return { text: result, width };
+      }
+      if (pendingAnsi) {
+        result += pendingAnsi;
+        pendingAnsi = "";
+      }
+      result += segment;
+      width += segmentWidth;
+    }
+
+    index = end;
+  }
+
+  return { text: result, width };
+}
+
+function finalizeTruncatedResult(
+  prefix: string,
+  prefixWidth: number,
+  ellipsis: string,
+  ellipsisWidth: number,
+  maxWidth: number,
+  pad: boolean,
+): string {
+  const width = prefixWidth + ellipsisWidth;
+  const result = ellipsis.length > 0 ? `${prefix}${ellipsis}` : prefix;
+  return pad ? result + " ".repeat(Math.max(0, maxWidth - width)) : result;
+}
+
+function readAnsiSequence(text: string, index: number): string | null {
+  const ESCAPE = "\u001b";
+  if (text[index] !== ESCAPE) return null;
+
+  const next = text[index + 1];
+  if (next === "[") {
+    const code = text.slice(index);
+    const pattern = new RegExp(`^${ESCAPE}\\[[0-?]*[ -/]*[@-~]`, "u");
+    const match = code.match(pattern);
+    return match?.[0] ?? text[index];
+  }
+
+  if (next === "]" || next === "_") {
+    const rest = text.slice(index);
+    const bel = rest.indexOf("\u0007");
+    const st = rest.indexOf("\u001b\\");
+    const end = [bel, st]
+      .filter((value) => value >= 0)
+      .sort((a, b) => a - b)[0];
+    if (end === undefined) return text[index];
+    return rest.slice(0, end + (end === st ? 2 : 1));
+  }
+
+  return text.slice(index, Math.min(index + 2, text.length));
+}

package/extensions/processes-dock/client.ts

@@ -0,0 +1,60 @@
+import type { EventBus } from "@earendil-works/pi-coding-agent";
+import {
+  CHANNELS,
+  type ProcessProtocolConfig,
+  type RequestCombinedOutputPayload,
+  type RequestConfigPayload,
+  type RequestGetPayload,
+  type RequestListPayload,
+} from "../../src/protocol";
+import type { ProcessInfo } from "../../src/types";
+
+export type ProcessLogLine = { type: "stdout" | "stderr"; text: string };
+
+export function requestProcessList(events: EventBus): ProcessInfo[] {
+  let processes: ProcessInfo[] = [];
+  const payload: RequestListPayload = {
+    reply: (result) => (processes = result),
+  };
+  events.emit(CHANNELS.REQUEST_LIST, payload);
+  return processes;
+}
+
+export function requestProcess(
+  events: EventBus,
+  id: string,
+): ProcessInfo | null {
+  let process: ProcessInfo | null = null;
+  const payload: RequestGetPayload = {
+    id,
+    reply: (result) => (process = result),
+  };
+  events.emit(CHANNELS.REQUEST_GET, payload);
+  return process;
+}
+
+export function requestCombinedOutput(
+  events: EventBus,
+  id: string,
+  tailLines?: number,
+): ProcessLogLine[] {
+  let lines: ProcessLogLine[] | null = null;
+  const payload: RequestCombinedOutputPayload = {
+    id,
+    tailLines,
+    reply: (result) => (lines = result),
+  };
+  events.emit(CHANNELS.REQUEST_COMBINED_OUTPUT, payload);
+  return lines ?? [];
+}
+
+export function requestConfig(events: EventBus): ProcessProtocolConfig {
+  let config: ProcessProtocolConfig | null = null;
+  const payload: RequestConfigPayload = {
+    reply: (result) => (config = result),
+  };
+  events.emit(CHANNELS.REQUEST_CONFIG, payload);
+  if (!config)
+    throw new Error("processes core extension did not reply to config request");
+  return config;
+}

package/extensions/processes-dock/commands/dock.ts

@@ -0,0 +1,70 @@
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+import type { DockController } from "../widget/setup";
+
+const ACTIONS = [
+  {
+    value: "expand",
+    description: "Show the expanded dock.",
+  },
+  {
+    value: "collapse",
+    description: "Show the compact dock.",
+  },
+  {
+    value: "close",
+    description: "Close the dock.",
+  },
+];
+
+export function registerDockCommand(
+  pi: Pick<ExtensionAPI, "registerCommand">,
+  getController: () => DockController | null,
+): void {
+  pi.registerCommand("ps:dock", {
+    description: "Expand, collapse, or close the managed process dock.",
+    getArgumentCompletions: (prefix: string) => completions(prefix),
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const controller = getController();
+      if (!controller) {
+        report(ctx, "Process dock is only available in UI mode.", "warning");
+        return;
+      }
+
+      const action = args.trim().split(/\s+/, 1)[0] || "expand";
+      if (action === "expand") controller.actions.expand();
+      else if (action === "collapse") controller.actions.collapse();
+      else if (action === "close") controller.actions.close();
+      else {
+        report(ctx, "Usage: /ps:dock [expand|collapse|close]", "warning");
+        return;
+      }
+
+      controller.refresh();
+    },
+  });
+}
+
+function completions(prefix: string): AutocompleteItem[] | null {
+  const normalized = prefix.trim().toLowerCase();
+  const items = ACTIONS.filter((action) =>
+    action.value.startsWith(normalized),
+  ).map((action) => ({
+    value: action.value,
+    label: action.value,
+    description: action.description,
+  }));
+  return items.length > 0 ? items : null;
+}
+
+function report(
+  ctx: ExtensionCommandContext,
+  message: string,
+  level: "info" | "warning",
+): void {
+  if (ctx.hasUI) ctx.ui.notify(message, level);
+  else console.log(message);
+}