@aliou/pi-processes 0.9.4 → 0.10.0

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

@@ -0,0 +1,320 @@
+import type { ProcessManager } from "../../../../src/manager";
+import type { ProcessInfo } from "../../../../src/types";
+import { LIVE_STATUSES } from "../../../../src/types";
+import { isRecord } from "../../../../src/utils/is-record";
+import type {
+  LogMatcherConfig,
+  NotificationRegistry,
+  WatchRemoveSpec,
+  WatchUpdateResult,
+} from "../../notifications/registry";
+import { normalizeLogMatchItems } from "../notify";
+import type { ProcessesParamsType } from "../schema";
+
+export interface UpdateDetails {
+  action: "update";
+  ok: boolean;
+  error?: string;
+  process?: ProcessInfo;
+  renamed: boolean;
+  previousName: string | null;
+  watches: {
+    mode: "append" | "replace" | "remove" | "clear" | null;
+    before: LogMatcherConfig[];
+    applied: LogMatcherConfig[];
+    count: number;
+    items: LogMatcherConfig[];
+  };
+}
+
+export function executeUpdate(
+  params: ProcessesParamsType,
+  manager: ProcessManager,
+  notifications: NotificationRegistry,
+): UpdateDetails {
+  if (!params.id) {
+    return {
+      action: "update",
+      ok: false,
+      error: "process update requires id",
+      renamed: false,
+      previousName: null,
+      watches: { mode: null, before: [], applied: [], count: 0, items: [] },
+    };
+  }
+
+  const before = manager.get(params.id);
+  if (!before) {
+    return {
+      action: "update",
+      ok: false,
+      error: `process not found: ${params.id}`,
+      renamed: false,
+      previousName: null,
+      watches: { mode: null, before: [], applied: [], count: 0, items: [] },
+    };
+  }
+
+  if (!LIVE_STATUSES.has(before.status)) {
+    return {
+      action: "update",
+      ok: false,
+      error: `process update requires a running process; ${params.id} has status ${before.status}`,
+      process: before,
+      renamed: false,
+      previousName: null,
+      watches: { mode: null, before: [], applied: [], count: 0, items: [] },
+    };
+  }
+
+  let process = before;
+  let renamed = false;
+  let previousName: string | null = null;
+
+  if (params.name !== undefined) {
+    const name = params.name.trim();
+    if (!name) {
+      return {
+        action: "update",
+        ok: false,
+        error: "process update name must be non-empty",
+        process: before,
+        renamed: false,
+        previousName: null,
+        watches: { mode: null, before: [], applied: [], count: 0, items: [] },
+      };
+    }
+
+    const renamedProcess = manager.rename(params.id, name);
+    if (!renamedProcess) {
+      return {
+        action: "update",
+        ok: false,
+        error: `process not found: ${params.id}`,
+        renamed: false,
+        previousName: null,
+        watches: { mode: null, before: [], applied: [], count: 0, items: [] },
+      };
+    }
+
+    renamed = before.name !== renamedProcess.name;
+    if (renamed) {
+      previousName = before.name;
+    }
+    process = renamedProcess;
+  }
+
+  let watchError: string | undefined;
+  const watchesBefore =
+    notifications.getWatchState(params.id)?.logMatches ?? [];
+  let watchesApplied: LogMatcherConfig[] = [];
+  const watchResult = applyWatchUpdate(
+    params.id,
+    params.watches,
+    notifications,
+  );
+
+  if (params.watches && !watchResult) {
+    watchError = `process update could not update watches for ${params.id}`;
+  }
+
+  if (watchResult) {
+    watchesApplied =
+      params.watches?.mode === "append" || params.watches?.mode === "replace"
+        ? watchResult.logMatches.slice(
+            params.watches.mode === "append" ? watchesBefore.length : 0,
+          )
+        : [];
+  }
+
+  const currentWatches =
+    watchResult?.logMatches ??
+    notifications.getWatchState(params.id)?.logMatches ??
+    [];
+
+  if (watchError) {
+    return {
+      action: "update",
+      ok: false,
+      error: watchError,
+      process,
+      renamed,
+      previousName,
+      watches: {
+        mode: params.watches?.mode ?? null,
+        before: watchesBefore,
+        applied: [],
+        count: currentWatches.length,
+        items: currentWatches,
+      },
+    };
+  }
+
+  return {
+    action: "update",
+    ok: true,
+    process,
+    renamed,
+    previousName,
+    watches: {
+      mode: params.watches?.mode ?? null,
+      before: watchesBefore,
+      applied: watchesApplied,
+      count: currentWatches.length,
+      items: currentWatches,
+    },
+  };
+}
+
+function applyWatchUpdate(
+  processId: string,
+  watches: ProcessesParamsType["watches"],
+  notifications: NotificationRegistry,
+): WatchUpdateResult | null {
+  if (!watches) return null;
+
+  const { mode } = watches;
+
+  if (mode === "clear") {
+    return notifications.clearWatches(processId);
+  }
+
+  const items = watches.items;
+  if (!items || items.length === 0) {
+    throw new Error(
+      `process update watches.items is required for mode=${mode}`,
+    );
+  }
+
+  if (mode === "append" || mode === "replace") {
+    const normalized = normalizeLogMatchItems(items, {
+      actionLabel: "process update",
+      pathPrefix: "watches.items",
+    });
+
+    return mode === "append"
+      ? notifications.appendWatches(processId, normalized)
+      : notifications.replaceWatches(processId, normalized);
+  }
+
+  if (mode === "remove") {
+    const specs = normalizeWatchRemoveSpecs(items);
+    return notifications.removeWatches(processId, specs);
+  }
+
+  throw new Error(`unsupported watch update mode: ${String(mode)}`);
+}
+
+interface RawRemoveItem {
+  index?: number;
+  pattern?: string;
+  mode?: string;
+  stream?: string;
+  repeat?: boolean;
+  on?: string;
+}
+
+function normalizeWatchRemoveSpecs(items: unknown[]): WatchRemoveSpec[] {
+  return items.map((raw, index) => {
+    if (!isRecord(raw)) {
+      throw new Error(
+        `process update watches.items[${index}] must be an object`,
+      );
+    }
+
+    const item = raw as RawRemoveItem;
+
+    if (item.index !== undefined) {
+      if (
+        typeof item.index !== "number" ||
+        !Number.isInteger(item.index) ||
+        item.index < 0
+      ) {
+        throw new Error(
+          `process update watches.items[${index}].index must be a non-negative integer`,
+        );
+      }
+
+      return { index: item.index };
+    }
+
+    if (item.pattern !== undefined) {
+      if (typeof item.pattern !== "string") {
+        throw new Error(
+          `process update watches.items[${index}].pattern must be a string`,
+        );
+      }
+
+      if (item.pattern.trim().length === 0) {
+        throw new Error(
+          `process update watches.items[${index}].pattern must not be empty`,
+        );
+      }
+
+      if (item.mode === "regex") {
+        try {
+          new RegExp(item.pattern);
+        } catch (error) {
+          const message =
+            error instanceof Error ? error.message : String(error);
+          throw new Error(
+            `process update watches.items[${index}].pattern is not a valid regular expression: ${message}`,
+          );
+        }
+      }
+
+      return {
+        pattern: item.pattern,
+        mode: item.mode as WatchRemoveSpec["mode"],
+        stream: item.stream as WatchRemoveSpec["stream"],
+        repeat: item.repeat,
+        on: item.on as WatchRemoveSpec["on"],
+      };
+    }
+
+    throw new Error(
+      `process update watches.items[${index}] requires either index or pattern for remove mode`,
+    );
+  });
+}
+
+export function formatUpdateDetails(details: UpdateDetails): string {
+  if (!details.ok) {
+    return details.error ?? "process update failed";
+  }
+
+  const parts: string[] = [];
+
+  if (details.renamed && details.previousName && details.process) {
+    parts.push(
+      `Renamed process from "${details.previousName}" to "${details.process.name}" (${details.process.id}).`,
+    );
+  } else if (details.process) {
+    parts.push(
+      `Updated process ${details.process.name} (${details.process.id}).`,
+    );
+  }
+
+  const { mode, applied, before, count } = details.watches;
+
+  if (mode === "append") {
+    parts.push(
+      `Appended ${applied.length} watch${applied.length === 1 ? "" : "es"}; ${count} active.`,
+    );
+  } else if (mode === "replace") {
+    parts.push(
+      `Replaced ${before.length} with ${applied.length} watch${applied.length === 1 ? "" : "es"}; ${count} active.`,
+    );
+  } else if (mode === "remove") {
+    const removed = before.length - count;
+    parts.push(
+      `Removed ${removed} watch${removed === 1 ? "" : "es"}; ${count} active.`,
+    );
+  } else if (mode === "clear") {
+    parts.push(
+      `Cleared ${before.length} watch${before.length === 1 ? "" : "es"}; ${count} active.`,
+    );
+  }
+
+  return parts.join(" ") || "Updated process.";
+}

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

@@ -0,0 +1,251 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Container, Text } from "@earendil-works/pi-tui";
+import type { LogMatcherConfig } from "../../notifications/registry";
+import { buildMatcherLine, ProcessActionHeader } from "../components";
+import type { ProcessesParamsType } from "../schema";
+import { buildField } from "../utils";
+import type { UpdateDetails } from ".";
+
+export function buildHeader(
+  args: ProcessesParamsType,
+  theme: Theme,
+  options?: { expanded?: boolean },
+): Container {
+  return new ProcessActionHeader(args, theme, {
+    action: "update",
+    expanded: options?.expanded,
+    suffix: args.id ? theme.fg("accent", `(${args.id})`) : undefined,
+  });
+}
+
+export function buildExpanded(details: UpdateDetails, theme: Theme): Container {
+  const container = new Container();
+
+  if (!details.ok) {
+    container.addChild(
+      new Text(theme.fg("error", details.error ?? "update failed"), 0, 0),
+    );
+    return container;
+  }
+
+  if (details.renamed && details.previousName && details.process) {
+    container.addChild(
+      new Text(
+        `${theme.fg("muted", "renamed:")} ${details.previousName} -> ${theme.fg("accent", details.process.name)}`,
+        0,
+        0,
+      ),
+    );
+  }
+
+  if (details.watches.mode) {
+    container.addChild(buildWatchSection(details, theme));
+  }
+
+  return container;
+}
+
+export function buildCollapsed(
+  details: UpdateDetails,
+  theme: Theme,
+): Container {
+  const container = new Container();
+
+  if (!details.ok) {
+    container.addChild(
+      new Text(theme.fg("error", details.error ?? "update failed"), 0, 0),
+    );
+    return container;
+  }
+
+  if (details.renamed && details.previousName && details.process) {
+    container.addChild(
+      buildField(
+        "renamed",
+        `${details.previousName} -> ${details.process.name}`,
+        theme,
+      ),
+    );
+  }
+
+  if (details.watches.mode) {
+    container.addChild(buildWatchSummary(details, theme));
+  }
+
+  return container;
+}
+
+export function buildFooter(
+  _details: UpdateDetails,
+  _options: { expanded?: boolean },
+  _theme: Theme,
+): Container | null {
+  return null;
+}
+
+// --- Collapsed summary ---
+
+function buildWatchSummary(details: UpdateDetails, theme: Theme): Container {
+  const container = new Container();
+  const { mode, applied, before, count } = details.watches;
+
+  if (mode === "append") {
+    container.addChild(
+      buildField(
+        "watches",
+        `${theme.fg("success", `appended ${applied.length}`)}; ${count} active`,
+        theme,
+      ),
+    );
+  } else if (mode === "replace") {
+    container.addChild(
+      buildField(
+        "watches",
+        `${theme.fg("accent", `replaced ${before.length} with ${applied.length}`)}; ${count} active`,
+        theme,
+      ),
+    );
+  } else if (mode === "remove") {
+    const removed = before.length - count;
+    container.addChild(
+      buildField(
+        "watches",
+        `${theme.fg("error", `removed ${removed}`)}; ${count} active`,
+        theme,
+      ),
+    );
+  } else if (mode === "clear") {
+    container.addChild(
+      buildField(
+        "watches",
+        `${theme.fg("error", `cleared ${before.length}`)}; ${count} active`,
+        theme,
+      ),
+    );
+  }
+
+  return container;
+}
+
+// --- Expanded watch details ---
+
+function buildWatchSection(details: UpdateDetails, theme: Theme): Container {
+  const container = new Container();
+  const { mode, applied, before, count } = details.watches;
+
+  // Summary line
+  if (mode === "append") {
+    container.addChild(
+      new Text(
+        theme.fg(
+          "muted",
+          `appended ${applied.length} watch${applied.length === 1 ? "" : "es"}; ${count} active`,
+        ),
+        0,
+        0,
+      ),
+    );
+  } else if (mode === "replace") {
+    container.addChild(
+      new Text(
+        theme.fg(
+          "muted",
+          `replaced ${before.length} with ${applied.length}; ${count} active`,
+        ),
+        0,
+        0,
+      ),
+    );
+  } else if (mode === "remove") {
+    const removed = before.length - count;
+    container.addChild(
+      new Text(
+        theme.fg(
+          "muted",
+          `removed ${removed} watch${removed === 1 ? "" : "es"}; ${count} active`,
+        ),
+        0,
+        0,
+      ),
+    );
+  } else if (mode === "clear") {
+    container.addChild(
+      new Text(
+        theme.fg(
+          "muted",
+          `cleared ${before.length} watch${before.length === 1 ? "" : "es"}; ${count} active`,
+        ),
+        0,
+        0,
+      ),
+    );
+  }
+
+  if (mode === "append") {
+    for (const matcher of applied) {
+      container.addChild(
+        buildMatcherLine(matcher, theme, theme.fg("success", "+ ")),
+      );
+    }
+  }
+
+  if (mode === "replace") {
+    for (const matcher of before) {
+      container.addChild(
+        buildMatcherLine(matcher, theme, theme.fg("error", "- ")),
+      );
+    }
+    for (const matcher of details.watches.items) {
+      container.addChild(
+        buildMatcherLine(matcher, theme, theme.fg("success", "+ ")),
+      );
+    }
+  }
+
+  if (mode === "remove") {
+    for (const matcher of findRemovedMatchers(before, details.watches.items)) {
+      container.addChild(
+        buildMatcherLine(matcher, theme, theme.fg("error", "- ")),
+      );
+    }
+  }
+
+  if (mode === "clear") {
+    for (const matcher of before) {
+      container.addChild(
+        buildMatcherLine(matcher, theme, theme.fg("error", "- ")),
+      );
+    }
+  }
+
+  return container;
+}
+
+export function findRemovedMatchers(
+  before: LogMatcherConfig[],
+  after: LogMatcherConfig[],
+): LogMatcherConfig[] {
+  const remaining = new Map<string, number>();
+  for (const matcher of after) {
+    const key = matcherKey(matcher);
+    remaining.set(key, (remaining.get(key) ?? 0) + 1);
+  }
+
+  return before.filter((matcher) => {
+    const key = matcherKey(matcher);
+    const count = remaining.get(key) ?? 0;
+    if (count === 0) return true;
+    remaining.set(key, count - 1);
+    return false;
+  });
+}
+
+function matcherKey(matcher: LogMatcherConfig): string {
+  return JSON.stringify([
+    matcher.pattern,
+    matcher.mode ?? "literal",
+    matcher.stream ?? "both",
+    matcher.repeat ?? false,
+    matcher.on ?? "turn",
+  ]);
+}

package/extensions/processes/tools/utils.ts

@@ -0,0 +1,112 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Container, Text } from "@earendil-works/pi-tui";
+
+import type { ProcessInfo } from "../../../src/types";
+import {
+  formatRuntime,
+  formatStatus,
+  formatTimestamp,
+  shortenPath,
+} from "../../../src/utils";
+import { statusColor } from "../../shared/ui";
+import { truncateToWidth } from "../utils/truncate";
+
+export interface RenderOptions {
+  expanded?: boolean;
+}
+
+export function buildField(
+  label: string,
+  value: string | number | null,
+  theme: Theme,
+): Text {
+  return new Text(
+    `${theme.fg("muted", `${label}:`)} ${String(value ?? "-")}`,
+    0,
+    0,
+  );
+}
+
+export function buildCommandField(
+  command: string,
+  theme: Theme,
+  options?: { truncate?: boolean },
+): Text {
+  const value = options?.truncate
+    ? truncateToWidth(command, 80, theme.fg("accent", "…"))
+    : command;
+  return buildField("command", theme.fg("accent", `\`${value}\``), theme);
+}
+
+export function buildProcessDetails(
+  process: ProcessInfo,
+  theme: Theme,
+  options?: { runtime?: boolean },
+): Container {
+  const container = new Container();
+  container.addChild(buildField("id", process.id, theme));
+  container.addChild(buildField("name", process.name, theme));
+  container.addChild(
+    buildField("status", formatColoredProcessStatus(process, theme), theme),
+  );
+  container.addChild(buildField("pid", process.pid, theme));
+  if (options?.runtime !== false) {
+    container.addChild(
+      buildField("duration", formatProcessRuntime(process), theme),
+    );
+  }
+  container.addChild(
+    buildField("started", formatTimestamp(process.startTime), theme),
+  );
+  container.addChild(buildField("cwd", shortenPath(process.cwd), theme));
+  container.addChild(buildCommandField(process.command, theme));
+  container.addChild(buildField("stdout", process.stdoutFile, theme));
+  container.addChild(buildField("stderr", process.stderrFile, theme));
+  return container;
+}
+
+export function buildProcessSummaryRow(
+  process: ProcessInfo,
+  theme: Theme,
+): Text {
+  return new Text(
+    [
+      process.name,
+      theme.fg("accent", process.id),
+      `pid ${process.pid}`,
+      formatColoredProcessStatus(process, theme),
+    ].join("  "),
+    0,
+    0,
+  );
+}
+
+export function buildCompactProcessLine(
+  process: ProcessInfo,
+  theme: Theme,
+): Text {
+  return buildField("process", `${process.id} / pid ${process.pid}`, theme);
+}
+
+export function formatProcessRuntime(
+  process: ProcessInfo,
+  now?: number,
+): string {
+  if (process.startTime <= 0) return "-";
+  return formatRuntime(process.startTime, process.endTime, now);
+}
+
+export function formatColoredProcessStatus(
+  process: ProcessInfo,
+  theme: Theme,
+): string {
+  return theme.fg(statusColor(process), formatStatus(process));
+}
+
+export function plural(noun: string, count: number): string {
+  return count === 1 ? noun : `${noun}s`;
+}
+
+export function formatCount(count: number, singular: string): string {
+  return `${count} ${plural(singular, count)}`;
+}

package/extensions/processes/tools/watch-format.ts

@@ -0,0 +1,14 @@
+import type { LogMatcherConfig } from "../notifications/registry";
+
+export function formatMatcherForModel(matcher: LogMatcherConfig): string {
+  const mode = matcher.mode ?? "literal";
+  const stream = matcher.stream ?? "both";
+  const repeat = matcher.repeat ? " (repeat)" : "";
+  const on = matcher.on ?? "turn";
+
+  return `[${stream}] ${mode} ${on}${repeat} ${JSON.stringify(matcher.pattern)}`;
+}
+
+export function formatPatternsForModel(matchers: LogMatcherConfig[]): string {
+  return JSON.stringify(matchers.map((matcher) => matcher.pattern));
+}