@aliou/pi-processes 0.9.4 → 0.10.0

package/src/tools/actions/write.ts

@@ -1,113 +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 WriteParams {
-  id?: string;
-  input?: string;
-  end?: boolean;
-}
-
-export function renderWriteCall(
-  args: WriteParams,
-  theme: Theme,
-): ToolCallHeader {
-  const optionArgs: Array<{ label: string; value: string }> = [];
-
-  if (args.input) {
-    optionArgs.push({ label: "input", value: args.input });
-    if (args.end) {
-      optionArgs.push({ label: "end", value: "true" });
-    }
-  }
-
-  return new ToolCallHeader(
-    {
-      toolName: "Process",
-      action: "write",
-      mainArg: args.id,
-      optionArgs,
-    },
-    theme,
-  );
-}
-
-export function executeWrite(
-  params: WriteParams,
-  manager: ProcessManager,
-): ExecuteResult {
-  const { id, input, end } = params;
-
-  if (!id) {
-    return {
-      content: [{ type: "text", text: "Missing required parameter: id" }],
-      details: {
-        action: "write",
-        success: false,
-        message: "Missing required parameter: id",
-      },
-    };
-  }
-
-  if (input === undefined) {
-    return {
-      content: [{ type: "text", text: "Missing required parameter: input" }],
-      details: {
-        action: "write",
-        success: false,
-        message: "Missing required parameter: input",
-      },
-    };
-  }
-
-  const process = manager.get(id);
-  if (!process) {
-    return {
-      content: [{ type: "text", text: `Process not found: ${id}` }],
-      details: {
-        action: "write",
-        success: false,
-        message: `Process not found: ${id}`,
-      },
-    };
-  }
-
-  const result = manager.writeToStdin(process.id, input, { end });
-
-  if (!result.ok) {
-    const messages: Record<string, string> = {
-      not_found: `Process not found: ${process.id}`,
-      process_exited: `Process has already exited: ${process.id}`,
-      stdin_closed: `Stdin already closed for process: ${process.id}`,
-      write_error: `Failed to write to stdin for process: ${process.id}`,
-    };
-
-    const message =
-      messages[result.reason] || `Unknown error: ${result.reason}`;
-
-    return {
-      content: [{ type: "text", text: message }],
-      details: {
-        action: "write",
-        success: false,
-        message,
-      },
-    };
-  }
-
-  const suffix = end ? " (stdin closed)" : "";
-  return {
-    content: [
-      {
-        type: "text",
-        text: `Wrote ${input.length} bytes to "${process.name}" (${process.id})${suffix}`,
-      },
-    ],
-    details: {
-      action: "write",
-      success: true,
-      message: `Wrote ${input.length} bytes to process stdin${suffix}`,
-    },
-  };
-}

package/src/tools/index.ts

@@ -1,207 +0,0 @@
-import { ToolBody } from "@aliou/pi-utils-ui";
-import { StringEnum } from "@earendil-works/pi-ai";
-import type {
-  AgentToolResult,
-  ExtensionAPI,
-  Theme,
-  ToolRenderResultOptions,
-} from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { type Static, Type } from "typebox";
-import type { ProcessesDetails } from "../constants";
-import type { ProcessManager } from "../manager";
-import { executeAction, renderActionCall, renderActionResult } from "./actions";
-
-const DEBUG_PREVIEW_ENABLED = process.env.PI_PROCESSES_DEBUG_PREVIEW === "1";
-
-const PROCESS_ACTIONS = [
-  "start",
-  "list",
-  "output",
-  "logs",
-  "kill",
-  "clear",
-  "write",
-  ...(DEBUG_PREVIEW_ENABLED ? (["debug_preview"] as const) : []),
-] as const;
-
-const ProcessesParams = Type.Object({
-  action: StringEnum(PROCESS_ACTIONS, {
-    description: DEBUG_PREVIEW_ENABLED
-      ? "Action: start (run command), list (show all), output (get recent output), logs (get log file paths), kill (terminate), clear (remove finished), write (write to stdin), debug_preview (temporary UI preview, no side effects)"
-      : "Action: start (run command), list (show all), output (get recent output), logs (get log file paths), kill (terminate), clear (remove finished), write (write to stdin)",
-  }),
-  command: Type.Optional(
-    Type.String({ description: "Command to run (required for start)" }),
-  ),
-  name: Type.Optional(
-    Type.String({
-      description:
-        "Friendly name for the process (required for start, e.g. 'backend-dev', 'test-runner')",
-    }),
-  ),
-  id: Type.Optional(
-    Type.String({
-      description:
-        "Process ID, returned by start and list actions (required for output/kill/logs/write)",
-    }),
-  ),
-  input: Type.Optional(
-    Type.String({
-      description: "Data to write to process stdin (required for write action)",
-    }),
-  ),
-  end: Type.Optional(
-    Type.Boolean({
-      description:
-        "Close stdin after writing (optional for write action, use for programs reading until EOF)",
-    }),
-  ),
-  alertOnSuccess: Type.Optional(
-    Type.Boolean({
-      description:
-        "Get a turn to react when process completes successfully (default: false). Use for builds/tests where you need confirmation.",
-    }),
-  ),
-  alertOnFailure: Type.Optional(
-    Type.Boolean({
-      description:
-        "Get a turn to react when process fails/crashes (default: true). Use to be alerted of unexpected failures.",
-    }),
-  ),
-  alertOnKill: Type.Optional(
-    Type.Boolean({
-      description:
-        "Get a turn to react when process is killed by external signal (default: false). Note: killing via tool never triggers a turn.",
-    }),
-  ),
-  preview: Type.Optional(
-    StringEnum(["start", "list", "output", "logs", "error"] as const, {
-      description:
-        "For action=debug_preview only: which rendered result variant to preview (default: start)",
-    }),
-  ),
-  cwd: Type.Optional(
-    Type.String({
-      description:
-        "Working directory for the command (for start action). Defaults to the session working directory. Prefer this over 'cd dir && command' shell wrappers.",
-    }),
-  ),
-  logWatches: Type.Optional(
-    Type.Array(
-      Type.Object(
-        {
-          pattern: Type.String({
-            description:
-              "Regular expression pattern to match against process output lines",
-          }),
-          stream: Type.Optional(
-            StringEnum(["stdout", "stderr", "both"] as const, {
-              description:
-                "Which stream to watch (default: both). Use stdout/stderr to reduce noise.",
-            }),
-          ),
-          repeat: Type.Optional(
-            Type.Boolean({
-              description:
-                "Trigger every time this pattern matches (default: false, one-time)",
-            }),
-          ),
-        },
-        { additionalProperties: false },
-      ),
-    ),
-  ),
-});
-
-type ProcessesParamsType = Static<typeof ProcessesParams>;
-
-export function setupProcessesTools(pi: ExtensionAPI, manager: ProcessManager) {
-  pi.registerTool<typeof ProcessesParams, ProcessesDetails>({
-    name: "process",
-    label: "Process",
-    description: `Manage background processes. Actions:
-- start: Run command in background (requires 'name' and 'command')
-  - cwd (optional): Working directory for the command. Defaults to the session working directory. Use the cwd parameter instead of 'cd dir && command' shell wrappers.
-  - alertOnSuccess (default: false): Get a turn to react when process completes successfully
-  - alertOnFailure (default: true): Get a turn to react when process crashes/fails
-  - alertOnKill (default: false): Get a turn to react if killed by external signal (killing via tool never triggers a turn)
-  - logWatches (optional): Runtime output watches that trigger immediate alerts while running
-    - pattern: regex string to match per output line
-    - stream: stdout | stderr | both (default both)
-    - repeat: false by default (single-fire). Set true for repeat alerts
-- list: Show all managed processes with their IDs and names
-- output: Get recent stdout/stderr (requires 'id')
-- logs: Get log file paths to inspect with read tool (requires 'id')
-- kill: Terminate a process (requires 'id')
-- clear: Remove all finished processes from the list
-- write: Write to process stdin (requires 'id' and 'input', optional 'end' to close stdin)
-${
-  DEBUG_PREVIEW_ENABLED
-    ? "- debug_preview: Temporary renderer preview for process tool UIs (no process side effects)\n  - preview: start | list | output | logs | error (default: start)\n"
-    : ""
-}
-Important: You DON'T need to poll or wait for processes. Notifications arrive automatically based on your preferences. Start processes and continue with other work - you'll be informed if something requires attention.
-
-Note: User always sees process updates in the UI. The notify flags control whether YOU (the agent) get a turn to react (e.g. check results, fix code, restart).`,
-    promptSnippet:
-      "Manage background processes without blocking the conversation",
-    promptGuidelines: [
-      "Use the process tool for long-running commands such as dev servers, test watchers, build watchers, and log tails instead of bash.",
-      "Avoid shell background patterns such as &, nohup, disown, or setsid when the process tool fits.",
-      "After starting a process, continue other work instead of waiting for it.",
-      "Use the pi-processes skill for examples and best practices when a task depends on background processes.",
-    ],
-
-    parameters: ProcessesParams,
-
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      return executeAction(params, manager, ctx);
-    },
-
-    renderCall(args: ProcessesParamsType, theme: Theme, _context) {
-      return renderActionCall(args, theme);
-    },
-
-    renderResult(
-      result: AgentToolResult<ProcessesDetails>,
-      options: ToolRenderResultOptions,
-      theme: Theme,
-      _context,
-    ) {
-      if (options.isPartial) {
-        return new Text(theme.fg("muted", "Process: running..."), 0, 0);
-      }
-
-      const { details } = result;
-
-      // Framework sets details to {} when tool throws.
-      // Detect by checking for missing expected fields.
-      if (!details?.action) {
-        const textBlock = result.content.find((c) => c.type === "text");
-        const errorMsg =
-          (textBlock?.type === "text" && textBlock.text) ||
-          "Tool execution failed";
-        return new Text(theme.fg("error", errorMsg), 0, 0);
-      }
-
-      if (!details.success) {
-        return new ToolBody(
-          {
-            fields: [
-              {
-                label: "Error",
-                value: theme.fg("error", details.message),
-                showCollapsed: true,
-              },
-            ],
-          },
-          options,
-          theme,
-        );
-      }
-
-      return renderActionResult(result, options, theme);
-    },
-  });
-}

package/src/utils/ansi.test.ts

@@ -1,22 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { stripAnsi } from "./ansi";
-
-describe("stripAnsi", () => {
-  it("strips CSI styling sequences", () => {
-    expect(stripAnsi("\u001b[31mred\u001b[0m")).toBe("red");
-  });
-
-  it("strips generic OSC sequences", () => {
-    expect(stripAnsi("\u001b]0;title\u0007hello")).toBe("hello");
-  });
-
-  it("strips carriage returns and other control chars that can corrupt TUI rendering", () => {
-    expect(stripAnsi("step 1\rstep 2\b\b done")).toBe("step 1step 2 done");
-    expect(stripAnsi("null\u0000byte")).toBe("nullbyte");
-    expect(stripAnsi("delete\u007fchar")).toBe("deletechar");
-  });
-
-  it("preserves tabs and newlines", () => {
-    expect(stripAnsi("one\ttwo\nthree")).toBe("one\ttwo\nthree");
-  });
-});

package/src/utils/command-executor.test.ts

@@ -1,48 +0,0 @@
-import type * as nodeFs from "node:fs";
-import { existsSync } from "node:fs";
-import { describe, expect, it, vi } from "vitest";
-import { resolveShellExecutable } from "./command-executor";
-
-vi.mock("node:fs", async (importOriginal) => {
-  const actual = await importOriginal<typeof nodeFs>();
-  return { ...actual, existsSync: vi.fn() };
-});
-
-const existsSyncMock = vi.mocked(existsSync);
-
-describe("resolveShellExecutable", () => {
-  it("prefers shell configured in settings when it is an existing absolute path", () => {
-    existsSyncMock.mockImplementation(
-      (path) => path === "/nix/store/abc-bash-5.3/bin/bash",
-    );
-
-    const resolved = resolveShellExecutable({
-      configuredShell: "/nix/store/abc-bash-5.3/bin/bash",
-      knownPaths: ["/bin/bash", "/usr/bin/bash"],
-    });
-
-    expect(resolved).toBe("/nix/store/abc-bash-5.3/bin/bash");
-  });
-
-  it("falls back to first existing known shell path", () => {
-    existsSyncMock.mockImplementation((path) => path === "/usr/bin/bash");
-
-    const resolved = resolveShellExecutable({
-      configuredShell: undefined,
-      knownPaths: ["/bin/bash", "/usr/bin/bash", "/usr/local/bin/bash"],
-    });
-
-    expect(resolved).toBe("/usr/bin/bash");
-  });
-
-  it("throws when no configured/known shell path exists", () => {
-    existsSyncMock.mockReturnValue(false);
-
-    expect(() =>
-      resolveShellExecutable({
-        configuredShell: undefined,
-        knownPaths: ["/bin/bash", "/usr/bin/bash"],
-      }),
-    ).toThrow(/shell/i);
-  });
-});

package/src/utils/keybindings.ts

@@ -1,71 +0,0 @@
-/**
- * Keyboard shortcuts configuration for the Process Dock.
- */
-
-export interface ProcessesKeybindings {
-  /** Toggle dock visibility (global) */
-  toggleDock: string;
-  /** Scroll logs up */
-  scrollUp: string;
-  /** Scroll logs down */
-  scrollDown: string;
-  /** Focus previous process */
-  prevProcess: string;
-  /** Focus next process */
-  nextProcess: string;
-  /** Toggle focus mode */
-  toggleFocus: string;
-  /** Kill focused process */
-  killProcess: string;
-  /** Clear finished processes */
-  clearFinished: string;
-  /** Collapse/close dock */
-  closeDock: string;
-}
-
-export const DEFAULT_KEYBINDINGS: ProcessesKeybindings = {
-  toggleDock: "", // Disabled - conflicts with editor shortcuts
-  scrollUp: "k",
-  scrollDown: "j",
-  prevProcess: "h",
-  nextProcess: "l",
-  toggleFocus: "f",
-  killProcess: "x",
-  clearFinished: "c",
-  closeDock: "q",
-};
-
-/**
- * Interface for config that may contain keybindings overrides
- */
-export interface ProcessesConfigKeybindings {
-  toggleDock?: string;
-  scrollUp?: string;
-  scrollDown?: string;
-  prevProcess?: string;
-  nextProcess?: string;
-  toggleFocus?: string;
-  killProcess?: string;
-  clearFinished?: string;
-  closeDock?: string;
-}
-
-/**
- * Load keybindings from config, falling back to defaults.
- */
-export function loadKeybindings(config: {
-  keybindings?: ProcessesConfigKeybindings;
-}): ProcessesKeybindings {
-  const user = config.keybindings ?? {};
-  return {
-    toggleDock: user.toggleDock ?? DEFAULT_KEYBINDINGS.toggleDock,
-    scrollUp: user.scrollUp ?? DEFAULT_KEYBINDINGS.scrollUp,
-    scrollDown: user.scrollDown ?? DEFAULT_KEYBINDINGS.scrollDown,
-    prevProcess: user.prevProcess ?? DEFAULT_KEYBINDINGS.prevProcess,
-    nextProcess: user.nextProcess ?? DEFAULT_KEYBINDINGS.nextProcess,
-    toggleFocus: user.toggleFocus ?? DEFAULT_KEYBINDINGS.toggleFocus,
-    killProcess: user.killProcess ?? DEFAULT_KEYBINDINGS.killProcess,
-    clearFinished: user.clearFinished ?? DEFAULT_KEYBINDINGS.clearFinished,
-    closeDock: user.closeDock ?? DEFAULT_KEYBINDINGS.closeDock,
-  };
-}