@aliou/pi-processes 0.9.5 → 0.10.1

package/src/tools/actions/clear.ts

@@ -1,20 +0,0 @@
-import type { ExecuteResult } from "../../constants";
-import type { ProcessManager } from "../../manager";
-
-export function executeClear(manager: ProcessManager): ExecuteResult {
-  const cleared = manager.clearFinished();
-  const message =
-    cleared > 0
-      ? `Cleared ${cleared} finished process(es)`
-      : "No finished processes to clear";
-
-  return {
-    content: [{ type: "text", text: message }],
-    details: {
-      action: "clear",
-      success: true,
-      message,
-      cleared,
-    },
-  };
-}

package/src/tools/actions/debug.ts

@@ -1,155 +0,0 @@
-import { ToolCallHeader } from "@aliou/pi-utils-ui";
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import type { ExecuteResult, ProcessInfo } from "../../constants";
-
-interface DebugParams {
-  preview?: "start" | "list" | "output" | "logs" | "error";
-}
-
-export function renderDebugCall(
-  args: DebugParams,
-  theme: Theme,
-): ToolCallHeader {
-  return new ToolCallHeader(
-    {
-      toolName: "Process",
-      action: "debug_preview",
-      mainArg: args.preview,
-    },
-    theme,
-  );
-}
-
-function mockProcess(overrides?: Partial<ProcessInfo>): ProcessInfo {
-  const now = Date.now();
-  return {
-    id: "proc_42",
-    name: "demo-server",
-    pid: 4242,
-    command: "pnpm dev --port 3000",
-    cwd: "/tmp/demo",
-    startTime: now - 12_000,
-    endTime: null,
-    status: "running",
-    exitCode: null,
-    success: null,
-    stdoutFile: "/tmp/pi-processes-demo/proc_42-stdout.log",
-    stderrFile: "/tmp/pi-processes-demo/proc_42-stderr.log",
-    alertOnSuccess: false,
-    alertOnFailure: true,
-    alertOnKill: false,
-    ...overrides,
-  };
-}
-
-/**
- * Temporary no-side-effect previews for process tool renderers.
- * Remove before release.
- */
-export function executeDebugPreview(params: DebugParams): ExecuteResult {
-  const preview = params.preview ?? "start";
-
-  if (preview === "start") {
-    const process = mockProcess();
-    const message = [
-      `Started "${process.name}" (${process.id}, PID: ${process.pid})`,
-      "Log files:",
-      `  stdout: ${process.stdoutFile}`,
-      `  stderr: ${process.stderrFile}`,
-    ].join("\n");
-    return {
-      content: [{ type: "text", text: message }],
-      details: {
-        action: "start",
-        success: true,
-        message,
-        process,
-      },
-    };
-  }
-
-  if (preview === "list") {
-    const processes = [
-      mockProcess(),
-      mockProcess({
-        id: "proc_11",
-        name: "builder",
-        pid: 1011,
-        command: "pnpm build --watch",
-      }),
-      mockProcess({
-        id: "proc_10",
-        name: "tests",
-        pid: 1010,
-        command: "pnpm test",
-        status: "exited",
-        success: false,
-        endTime: Date.now() - 3_000,
-        exitCode: 1,
-      }),
-    ];
-
-    return {
-      content: [{ type: "text", text: "Debug preview: list" }],
-      details: {
-        action: "list",
-        success: true,
-        message: "Debug preview: list",
-        processes,
-      },
-    };
-  }
-
-  if (preview === "output") {
-    const message =
-      '"demo-server" (proc_42) [running]: 4 stdout lines, 2 stderr lines';
-    const content = [
-      message,
-      "stdout:",
-      "starting...",
-      "loading config",
-      "ready on http://localhost:3000",
-      "watching for changes",
-      "",
-      "stderr:",
-      "warn: deprecated option in config",
-      "error: simulated stack trace line",
-      "",
-      "Process is still running. Use watches instead of polling.",
-      "",
-      "[Complete currently-retained logs:",
-      "stdout=/tmp/pi-processes-demo/proc_42-stdout.log",
-      "stderr=/tmp/pi-processes-demo/proc_42-stderr.log]",
-    ].join("\n");
-
-    return {
-      content: [{ type: "text", text: content }],
-      details: {
-        action: "output",
-        success: true,
-        message,
-        logFiles: {
-          stdoutFile: "/tmp/pi-processes-demo/proc_42-stdout.log",
-          stderrFile: "/tmp/pi-processes-demo/proc_42-stderr.log",
-        },
-      },
-    };
-  }
-
-  if (preview === "logs") {
-    return {
-      content: [{ type: "text", text: "Debug preview: logs" }],
-      details: {
-        action: "logs",
-        success: true,
-        message: "Debug preview: logs",
-        logFiles: {
-          stdoutFile: "/tmp/pi-processes-demo/proc_42-stdout.log",
-          stderrFile: "/tmp/pi-processes-demo/proc_42-stderr.log",
-        },
-      },
-    };
-  }
-
-  throw new Error("Invalid logWatches[0].pattern: Unterminated group");
-}

package/src/tools/actions/index.ts

@@ -1,171 +0,0 @@
-import { ToolBody, ToolCallHeader } from "@aliou/pi-utils-ui";
-import type {
-  AgentToolResult,
-  ExtensionContext,
-  Theme,
-  ToolRenderResultOptions,
-} from "@earendil-works/pi-coding-agent";
-import type { Component } from "@earendil-works/pi-tui";
-import type {
-  ExecuteResult,
-  ProcessAction,
-  ProcessesDetails,
-} from "../../constants";
-import type { ProcessManager } from "../../manager";
-import { executeClear } from "./clear";
-import { executeDebugPreview, renderDebugCall } from "./debug";
-import { executeKill, renderKillCall } from "./kill";
-import { executeList, renderListResult } from "./list";
-import { executeLogs, renderLogsCall, renderLogsResult } from "./logs";
-import { executeOutput, renderOutputCall, renderOutputResult } from "./output";
-import { executeStart, renderStartCall, renderStartResult } from "./start";
-import { executeWrite, renderWriteCall } from "./write";
-
-const DEBUG_PREVIEW_ENABLED = process.env.PI_PROCESSES_DEBUG_PREVIEW === "1";
-
-interface ActionParams {
-  action: ProcessAction | string;
-  command?: string;
-  name?: string;
-  id?: string;
-  input?: string;
-  end?: boolean;
-  cwd?: string;
-  alertOnSuccess?: boolean;
-  alertOnFailure?: boolean;
-  alertOnKill?: boolean;
-  logWatches?: Array<{
-    pattern: string;
-    stream?: "stdout" | "stderr" | "both";
-    repeat?: boolean;
-  }>;
-  preview?: "start" | "list" | "output" | "logs" | "error";
-}
-
-export async function executeAction(
-  params: ActionParams,
-  manager: ProcessManager,
-  ctx: ExtensionContext,
-): Promise<ExecuteResult> {
-  switch (params.action) {
-    case "start":
-      return executeStart(params, manager, ctx);
-    case "list":
-      return executeList(manager);
-    case "output":
-      return executeOutput(params, manager);
-    case "logs":
-      return executeLogs(params, manager);
-    case "kill":
-      return executeKill(params, manager);
-    case "clear":
-      return executeClear(manager);
-    case "write":
-      return executeWrite(params, manager);
-    case "debug_preview":
-      if (!DEBUG_PREVIEW_ENABLED) {
-        throw new Error(
-          "Action 'debug_preview' is disabled. Set PI_PROCESSES_DEBUG_PREVIEW=1 to enable.",
-        );
-      }
-      return executeDebugPreview(params);
-    default:
-      return {
-        content: [{ type: "text", text: `Unknown action: ${params.action}` }],
-        details: {
-          action: params.action as ProcessAction,
-          success: false,
-          message: `Unknown action: ${params.action}`,
-        },
-      };
-  }
-}
-
-export function renderActionCall(args: ActionParams, theme: Theme): Component {
-  switch (args.action) {
-    case "start":
-      return renderStartCall(args, theme);
-    case "output":
-      return renderOutputCall(args, theme);
-    case "logs":
-      return renderLogsCall(args, theme);
-    case "kill":
-      return renderKillCall(args, theme);
-    case "write":
-      return renderWriteCall(args, theme);
-    case "debug_preview":
-      return renderDebugCall(args, theme);
-    default:
-      return new ToolCallHeader(
-        { toolName: "Process", action: args.action },
-        theme,
-      );
-  }
-}
-
-export function renderActionResult(
-  result: AgentToolResult<ProcessesDetails>,
-  options: ToolRenderResultOptions,
-  theme: Theme,
-): Component {
-  const { details } = result;
-
-  if (!details) {
-    return new ToolBody(
-      {
-        fields: [
-          {
-            label: "Result",
-            value: "No result details available.",
-            showCollapsed: true,
-          },
-        ],
-      },
-      options,
-      theme,
-    );
-  }
-
-  switch (details.action) {
-    case "start":
-      return renderStartResult(result, options, theme);
-    case "list":
-      return renderListResult(result, options, theme);
-    case "output":
-      return renderOutputResult(result, options, theme);
-    case "logs":
-      return renderLogsResult(result, options, theme);
-    case "kill":
-    case "write":
-    case "clear":
-    case "debug_preview":
-      // Default rendering for these actions
-      return new ToolBody(
-        {
-          fields: [
-            {
-              label: "Result",
-              value: details.message,
-              showCollapsed: true,
-            },
-          ],
-        },
-        options,
-        theme,
-      );
-    default:
-      return new ToolBody(
-        {
-          fields: [
-            {
-              label: "Result",
-              value: details.message,
-              showCollapsed: true,
-            },
-          ],
-        },
-        options,
-        theme,
-      );
-  }
-}

package/src/tools/actions/kill.ts

@@ -1,89 +0,0 @@
-import { ToolCallHeader } from "@aliou/pi-utils-ui";
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import type { ExecuteResult } from "../../constants";
-import type { ProcessManager } from "../../manager";
-
-interface KillParams {
-  id?: string;
-}
-
-export function renderKillCall(args: KillParams, theme: Theme): ToolCallHeader {
-  return new ToolCallHeader(
-    {
-      toolName: "Process",
-      action: "kill",
-      mainArg: args.id,
-    },
-    theme,
-  );
-}
-
-export async function executeKill(
-  params: KillParams,
-  manager: ProcessManager,
-): Promise<ExecuteResult> {
-  if (!params.id) {
-    return {
-      content: [{ type: "text", text: "Missing required parameter: id" }],
-      details: {
-        action: "kill",
-        success: false,
-        message: "Missing required parameter: id",
-      },
-    };
-  }
-
-  const proc = manager.get(params.id);
-  if (!proc) {
-    const message = `Process not found: ${params.id}`;
-    return {
-      content: [{ type: "text", text: message }],
-      details: {
-        action: "kill",
-        success: false,
-        message,
-      },
-    };
-  }
-
-  const result = await manager.kill(proc.id, {
-    signal: "SIGTERM",
-    timeoutMs: 3000,
-  });
-
-  if (result.ok) {
-    const message = `Terminated "${proc.name}" (${proc.id})`;
-    return {
-      content: [{ type: "text", text: message }],
-      details: {
-        action: "kill",
-        success: true,
-        message,
-      },
-    };
-  }
-
-  if (result.reason === "timeout") {
-    const message =
-      `SIGTERM timed out for "${proc.name}" (${proc.id}). ` +
-      "Run /ps and press x on terminate_timeout to force kill (SIGKILL).";
-    return {
-      content: [{ type: "text", text: message }],
-      details: {
-        action: "kill",
-        success: false,
-        message,
-      },
-    };
-  }
-
-  const message = `Failed to terminate "${proc.name}" (${proc.id})`;
-  return {
-    content: [{ type: "text", text: message }],
-    details: {
-      action: "kill",
-      success: false,
-      message,
-    },
-  };
-}

package/src/tools/actions/list.ts

@@ -1,188 +0,0 @@
-import { ToolBody, ToolFooter } from "@aliou/pi-utils-ui";
-import type {
-  AgentToolResult,
-  Theme,
-  ToolRenderResultOptions,
-} from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import type { ExecuteResult, ProcessesDetails } from "../../constants";
-import type { ProcessManager } from "../../manager";
-import {
-  formatRuntime,
-  formatStatus,
-  formatStatusTag,
-  formatTimestamp,
-  truncateCmd,
-} from "../../utils";
-
-export function executeList(manager: ProcessManager): ExecuteResult {
-  const processes = manager.list();
-
-  if (processes.length === 0) {
-    return {
-      content: [{ type: "text", text: "No background processes running" }],
-      details: {
-        action: "list",
-        success: true,
-        message: "No background processes running",
-        processes: [],
-      },
-    };
-  }
-
-  const summary = processes
-    .map(
-      (p) =>
-        `${p.id} "${p.name}": ${truncateCmd(p.command)} [${formatStatus(p)}] ${formatRuntime(p.startTime, p.endTime)}`,
-    )
-    .join("\n");
-
-  const message = `${processes.length} process(es):\n${summary}`;
-  return {
-    content: [{ type: "text", text: message }],
-    details: {
-      action: "list",
-      success: true,
-      message,
-      processes,
-    },
-  };
-}
-
-export function renderListResult(
-  result: AgentToolResult<ProcessesDetails>,
-  options: ToolRenderResultOptions,
-  theme: Theme,
-): ToolBody {
-  const { details } = result;
-
-  if (!details.processes || details.processes.length === 0) {
-    return new ToolBody(
-      {
-        fields: [
-          {
-            label: "Processes",
-            value: "No background processes running",
-            showCollapsed: true,
-          },
-        ],
-      },
-      options,
-      theme,
-    );
-  }
-
-  const processes = [...details.processes];
-
-  const statusRank = (status: string): number => {
-    switch (status) {
-      case "running":
-        return 0;
-      case "terminating":
-        return 1;
-      case "terminate_timeout":
-        return 2;
-      case "killed":
-        return 3;
-      case "exited":
-        return 4;
-      default:
-        return 5;
-    }
-  };
-
-  processes.sort((a, b) => {
-    const rankDiff = statusRank(a.status) - statusRank(b.status);
-    if (rankDiff !== 0) return rankDiff;
-    return b.startTime - a.startTime;
-  });
-
-  const runningCount = processes.filter(
-    (p) => p.status === "running" || p.status === "terminating",
-  ).length;
-
-  const lines: string[] = [
-    theme.fg(
-      "success",
-      `${processes.length} process(es), ${runningCount} running/terminating`,
-    ),
-  ];
-
-  for (const process of processes) {
-    const status = formatStatusTag(process, theme);
-    lines.push(
-      [
-        `- ${theme.fg("accent", process.name)} ${theme.fg("muted", `(${process.id})`)}`,
-        `  pid: ${process.pid}   status: ${status}`,
-        `  started: ${theme.fg("muted", formatTimestamp(process.startTime))}`,
-        `  ended:   ${theme.fg("muted", formatTimestamp(process.endTime))}`,
-        `  runtime: ${theme.fg("muted", formatRuntime(process.startTime, process.endTime))}`,
-      ].join("\n"),
-    );
-  }
-
-  const fields: Array<
-    { label: string; value: string; showCollapsed?: boolean } | Text
-  > = [new Text(lines.join("\n"), 0, 0)];
-
-  const running = details.processes.filter(
-    (p) => p.status === "running" || p.status === "terminating",
-  );
-  const finishedOk = details.processes.filter(
-    (p) => p.status === "exited" && p.success,
-  ).length;
-  const failed = details.processes.filter(
-    (p) => p.status === "exited" && !p.success,
-  ).length;
-  const killed = details.processes.filter((p) => p.status === "killed").length;
-
-  const runningSummary =
-    running.length > 0
-      ? running
-          .slice(0, 3)
-          .map(
-            (p) =>
-              `${theme.fg("accent", `"${p.name}"`)} [${formatStatusTag(p, theme)}]`,
-          )
-          .join(", ")
-      : theme.fg("muted", "no running process");
-
-  const restParts: string[] = [];
-  if (finishedOk > 0) restParts.push(`${finishedOk} finished`);
-  if (failed > 0) restParts.push(`${failed} failed`);
-  if (killed > 0) restParts.push(`${killed} killed`);
-  const restSummary =
-    restParts.length > 0 ? theme.fg("muted", ` + ${restParts.join(", ")}`) : "";
-
-  fields.push({
-    label: "Processes",
-    value: runningSummary + restSummary,
-    showCollapsed: true,
-  });
-
-  const footerItems: Array<{
-    label: string;
-    value: string;
-  }> = [];
-  if (runningCount > 0) {
-    footerItems.push({ label: "running", value: String(runningCount) });
-  }
-  if (failed > 0) {
-    footerItems.push({ label: "failed", value: String(failed) });
-  }
-  if (killed > 0) {
-    footerItems.push({ label: "killed", value: String(killed) });
-  }
-
-  return new ToolBody(
-    {
-      fields,
-      footer:
-        footerItems.length > 0
-          ? new ToolFooter(theme, { items: footerItems, separator: " | " })
-          : undefined,
-    },
-    options,
-    theme,
-  );
-}