@aliou/pi-processes 0.2.1 → 0.3.0

package/hooks/process-end.ts

@@ -37,11 +37,13 @@ export function setupProcessEndHook(pi: ExtensionAPI, manager: ProcessManager) {
 
     const info: ProcessInfo = event.info;
 
-    // Check notification preferences
-    const shouldNotify =
-      (info.status === "killed" && info.notifyOnKill) ||
-      (info.status === "exited" && info.success && info.notifyOnSuccess) ||
-      (info.status === "exited" && !info.success && info.notifyOnFailure);
+    // Determine if the agent should get a turn to react to this process ending.
+    // When true, the agent receives the message in its context and can respond
+    // (e.g. check results, fix code, restart the process).
+    const triggerAgentTurn =
+      (info.status === "killed" && info.alertOnKill) ||
+      (info.status === "exited" && info.success && info.alertOnSuccess) ||
+      (info.status === "exited" && !info.success && info.alertOnFailure);
 
     const runtime = formatRuntime(info.startTime, info.endTime);
 
@@ -65,27 +67,26 @@ export function setupProcessEndHook(pi: ExtensionAPI, manager: ProcessManager) {
       latestContext.ui.notify(message, level);
     }
 
-    // Only send message to agent if notification preferences allow
-    if (shouldNotify) {
-      const details: ProcessUpdateDetails = {
-        processId: info.id,
-        processName: info.name,
-        command: info.command,
-        status: info.status as "exited" | "killed",
-        exitCode: info.exitCode,
-        success: info.success ?? false,
-        runtime,
-      };
+    // Always send the message so it appears in the conversation history.
+    // Only trigger an agent turn when the notification preferences say so.
+    const details: ProcessUpdateDetails = {
+      processId: info.id,
+      processName: info.name,
+      command: info.command,
+      status: info.status as "exited" | "killed",
+      exitCode: info.exitCode,
+      success: info.success ?? false,
+      runtime,
+    };
 
-      pi.sendMessage(
-        {
-          customType: MESSAGE_TYPE_PROCESS_UPDATE,
-          content: message,
-          display: true,
-          details,
-        },
-        { triggerTurn: false },
-      );
-    }
+    pi.sendMessage(
+      {
+        customType: MESSAGE_TYPE_PROCESS_UPDATE,
+        content: message,
+        display: true,
+        details,
+      },
+      { triggerTurn: triggerAgentTurn },
+    );
   });
 }

package/hooks/widget.ts

@@ -2,6 +2,7 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@mariozechner/pi-coding-agent";
+import { visibleWidth } from "@mariozechner/pi-tui";
 import type { ProcessInfo } from "../constants";
 import type { ProcessManager } from "../manager";
 
@@ -36,6 +37,7 @@ function formatProcessStatus(
 function renderWidget(
   processes: ProcessInfo[],
   theme: ExtensionContext["ui"]["theme"],
+  maxWidth?: number,
 ): string[] {
   if (processes.length === 0) {
     return [];
@@ -54,27 +56,48 @@ function renderWidget(
       p.status !== "terminate_timeout",
   );
 
-  const parts: string[] = [];
+  const allProcs: ProcessInfo[] = [
+    ...aliveish,
+    ...finished.sort((a, b) => (b.endTime ?? 0) - (a.endTime ?? 0)),
+  ];
 
-  for (const proc of aliveish) {
-    parts.push(formatProcessStatus(proc, theme));
-  }
+  const prefix = theme.fg("dim", "processes: ");
+  const prefixLen = visibleWidth(prefix);
+  const separator = theme.fg("dim", " | ");
+  const separatorLen = visibleWidth(separator);
+  const effectiveMax = maxWidth ?? 200;
 
-  const recentFinished = finished
-    .sort((a, b) => (b.endTime ?? 0) - (a.endTime ?? 0))
-    .slice(0, 3);
+  const parts: string[] = [];
+  let currentLen = prefixLen;
+  let includedCount = 0;
+
+  for (const proc of allProcs) {
+    const formatted = formatProcessStatus(proc, theme);
+    const formattedLen = visibleWidth(formatted);
+
+    // Check if adding this part would exceed the width
+    const needed =
+      includedCount > 0 ? separatorLen + formattedLen : formattedLen;
+
+    if (currentLen + needed > effectiveMax && includedCount > 0) {
+      // Show how many are hidden
+      const remaining = allProcs.length - includedCount;
+      if (remaining > 0) {
+        parts.push(theme.fg("dim", `+${remaining} more`));
+      }
+      break;
+    }
 
-  for (const proc of recentFinished) {
-    parts.push(formatProcessStatus(proc, theme));
+    parts.push(formatted);
+    currentLen += needed;
+    includedCount++;
   }
 
-  const hiddenCount = finished.length - recentFinished.length;
-  if (hiddenCount > 0) {
-    parts.push(theme.fg("dim", `+${hiddenCount} more`));
+  if (parts.length === 0) {
+    return [];
   }
 
-  const prefix = theme.fg("dim", "processes: ");
-  return [prefix + parts.join(theme.fg("dim", " | "))];
+  return [prefix + parts.join(separator)];
 }
 
 export function setupProcessWidget(pi: ExtensionAPI, manager: ProcessManager) {
@@ -84,7 +107,8 @@ export function setupProcessWidget(pi: ExtensionAPI, manager: ProcessManager) {
     if (!latestContext?.hasUI) return;
 
     const processes = manager.list();
-    const lines = renderWidget(processes, latestContext.ui.theme);
+    const maxWidth = process.stdout.columns || 120;
+    const lines = renderWidget(processes, latestContext.ui.theme, maxWidth);
 
     if (lines.length === 0) {
       latestContext.ui.setWidget(WIDGET_ID, undefined);

package/manager.ts

@@ -148,9 +148,9 @@ export class ProcessManager {
       success: null,
       stdoutFile,
       stderrFile,
-      notifyOnSuccess: options?.notifyOnSuccess ?? false,
-      notifyOnFailure: options?.notifyOnFailure ?? true,
-      notifyOnKill: options?.notifyOnKill ?? false,
+      alertOnSuccess: options?.alertOnSuccess ?? false,
+      alertOnFailure: options?.alertOnFailure ?? true,
+      alertOnKill: options?.alertOnKill ?? false,
       process: child,
       lastSignalSent: null,
     };
@@ -306,9 +306,9 @@ export class ProcessManager {
           success: false,
           stdoutFile: "",
           stderrFile: "",
-          notifyOnSuccess: false,
-          notifyOnFailure: true,
-          notifyOnKill: false,
+          alertOnSuccess: false,
+          alertOnFailure: true,
+          alertOnKill: false,
         },
         reason: "not_found",
       };
@@ -317,7 +317,7 @@ export class ProcessManager {
     const signal = opts?.signal ?? "SIGTERM";
     const timeoutMs = opts?.timeoutMs ?? 3000;
 
-    managed.notifyOnKill = false;
+    managed.alertOnKill = false;
 
     if (!LIVE_STATUSES.has(managed.status)) {
       return { ok: true, info: this.toProcessInfo(managed) };
@@ -468,9 +468,9 @@ export class ProcessManager {
       success: managed.success,
       stdoutFile: managed.stdoutFile,
       stderrFile: managed.stderrFile,
-      notifyOnSuccess: managed.notifyOnSuccess,
-      notifyOnFailure: managed.notifyOnFailure,
-      notifyOnKill: managed.notifyOnKill,
+      alertOnSuccess: managed.alertOnSuccess,
+      alertOnFailure: managed.alertOnFailure,
+      alertOnKill: managed.alertOnKill,
     };
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-processes",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "type": "module",
   "private": false,
   "keywords": [
@@ -32,8 +32,8 @@
     "@sinclair/typebox": "^0.34.41"
   },
   "peerDependencies": {
-    "@mariozechner/pi-ai": "0.50.0",
-    "@mariozechner/pi-coding-agent": "0.50.0",
-    "@mariozechner/pi-tui": "0.50.0"
+    "@mariozechner/pi-ai": "0.50.4",
+    "@mariozechner/pi-coding-agent": "0.50.4",
+    "@mariozechner/pi-tui": "0.50.4"
   }
 }

package/tools/actions/index.ts

@@ -13,9 +13,9 @@ interface ActionParams {
   command?: string;
   name?: string;
   id?: string;
-  notifyOnSuccess?: boolean;
-  notifyOnFailure?: boolean;
-  notifyOnKill?: boolean;
+  alertOnSuccess?: boolean;
+  alertOnFailure?: boolean;
+  alertOnKill?: boolean;
 }
 
 export async function executeAction(

package/tools/actions/output.ts

@@ -1,6 +1,9 @@
 import type { ExecuteResult } from "../../constants";
 import type { ProcessManager } from "../../manager";
-import { formatStatus } from "../../utils";
+import { formatStatus, stripAnsi } from "../../utils";
+
+const MAX_LINES = 200;
+const MAX_BYTES = 50 * 1024; // 50KB
 
 interface OutputParams {
   id?: string;
@@ -47,22 +50,28 @@ export function executeOutput(
     };
   }
 
+  const logFiles = manager.getLogFiles(proc.id);
   const stdoutLines = output.stdout.length;
   const stderrLines = output.stderr.length;
   const message = `"${proc.name}" (${proc.id}) [${formatStatus(proc)}]: ${stdoutLines} stdout lines, ${stderrLines} stderr lines`;
 
+  // Build the full text content (ANSI-stripped), then truncate from the tail
+  // like bash does, so the agent sees the most recent output.
   const outputParts: string[] = [message];
   if (output.stdout.length > 0) {
-    outputParts.push("\n--- stdout (last 100 lines) ---");
-    outputParts.push(...output.stdout.slice(-100));
+    outputParts.push("\nstdout:");
+    outputParts.push(...output.stdout.map(stripAnsi));
   }
   if (output.stderr.length > 0) {
-    outputParts.push("\n--- stderr (last 100 lines) ---");
-    outputParts.push(...output.stderr.slice(-100));
+    outputParts.push("\nstderr:");
+    outputParts.push(...output.stderr.map(stripAnsi));
   }
 
+  const fullText = outputParts.join("\n");
+  const contentText = truncateTail(fullText, logFiles);
+
   return {
-    content: [{ type: "text", text: outputParts.join("\n") }],
+    content: [{ type: "text", text: contentText }],
     details: {
       action: "output",
       success: true,
@@ -71,3 +80,62 @@ export function executeOutput(
     },
   };
 }
+
+/**
+ * Truncate text from the tail (keep last N lines / MAX_BYTES), matching
+ * the behaviour of pi's built-in bash tool.  When truncated, appends a
+ * notice pointing the agent to the full log files.
+ */
+function truncateTail(
+  text: string,
+  logFiles: { stdoutFile: string; stderrFile: string } | null,
+): string {
+  const totalBytes = Buffer.byteLength(text, "utf-8");
+  const lines = text.split("\n");
+  const totalLines = lines.length;
+
+  if (totalLines <= MAX_LINES && totalBytes <= MAX_BYTES) {
+    return text;
+  }
+
+  // Work backwards, collecting lines that fit
+  const kept: string[] = [];
+  let keptBytes = 0;
+  let hitBytes = false;
+
+  for (let i = lines.length - 1; i >= 0 && kept.length < MAX_LINES; i--) {
+    const line = lines[i] ?? "";
+    const lineBytes =
+      Buffer.byteLength(line, "utf-8") + (kept.length > 0 ? 1 : 0);
+
+    if (keptBytes + lineBytes > MAX_BYTES) {
+      hitBytes = true;
+      break;
+    }
+
+    kept.unshift(line);
+    keptBytes += lineBytes;
+  }
+
+  let result = kept.join("\n");
+
+  // Append a notice so the agent knows output was truncated
+  const shownLines = kept.length;
+  const startLine = totalLines - shownLines + 1;
+  const sizeNote = hitBytes ? ` (${formatSize(MAX_BYTES)} limit)` : "";
+  result += `\n\n[Showing lines ${startLine}-${totalLines} of ${totalLines}${sizeNote}.`;
+
+  if (logFiles) {
+    result += ` Full logs: ${logFiles.stdoutFile} , ${logFiles.stderrFile}`;
+  }
+
+  result += "]";
+
+  return result;
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}

package/tools/actions/start.ts

@@ -5,9 +5,9 @@ import type { ProcessManager } from "../../manager";
 interface StartParams {
   name?: string;
   command?: string;
-  notifyOnSuccess?: boolean;
-  notifyOnFailure?: boolean;
-  notifyOnKill?: boolean;
+  alertOnSuccess?: boolean;
+  alertOnFailure?: boolean;
+  alertOnKill?: boolean;
 }
 
 export function executeStart(
@@ -37,9 +37,9 @@ export function executeStart(
   }
 
   const proc = manager.start(params.name, params.command, ctx.cwd, {
-    notifyOnSuccess: params.notifyOnSuccess,
-    notifyOnFailure: params.notifyOnFailure,
-    notifyOnKill: params.notifyOnKill,
+    alertOnSuccess: params.alertOnSuccess,
+    alertOnFailure: params.alertOnFailure,
+    alertOnKill: params.alertOnKill,
   });
 
   const message = `Started "${proc.name}" (${proc.id}, PID: ${proc.pid})\nLogs: ${proc.stdoutFile}`;

package/tools/index.ts

@@ -9,7 +9,7 @@ import { Text } from "@mariozechner/pi-tui";
 import { type Static, Type } from "@sinclair/typebox";
 import type { ProcessesDetails } from "../constants";
 import type { ProcessManager } from "../manager";
-import { formatRuntime, truncateCmd } from "../utils";
+import { formatRuntime, hasAnsi, stripAnsi, truncateCmd } from "../utils";
 import { executeAction } from "./actions";
 
 const ProcessesParams = Type.Object({
@@ -35,22 +35,22 @@ const ProcessesParams = Type.Object({
         "Process ID or name to match (required for output/kill/logs). Can be proc_N or friendly name.",
     }),
   ),
-  notifyOnSuccess: Type.Optional(
+  alertOnSuccess: Type.Optional(
     Type.Boolean({
       description:
-        "Notify when process completes successfully (default: false). Use for builds/tests where you need confirmation.",
+        "Get a turn to react when process completes successfully (default: false). Use for builds/tests where you need confirmation.",
     }),
   ),
-  notifyOnFailure: Type.Optional(
+  alertOnFailure: Type.Optional(
     Type.Boolean({
       description:
-        "Notify when process fails/crashes (default: true). Use to be alerted of unexpected failures.",
+        "Get a turn to react when process fails/crashes (default: true). Use to be alerted of unexpected failures.",
     }),
   ),
-  notifyOnKill: Type.Optional(
+  alertOnKill: Type.Optional(
     Type.Boolean({
       description:
-        "Notify when process is killed by external signal (default: false). Note: killing via tool never notifies.",
+        "Get a turn to react when process is killed by external signal (default: false). Note: killing via tool never triggers a turn.",
     }),
   ),
 });
@@ -63,9 +63,9 @@ export function setupProcessesTools(pi: ExtensionAPI, manager: ProcessManager) {
     label: "Processes",
     description: `Manage background processes. Actions:
 - start: Run command in background (requires 'name' and 'command')
-  - notifyOnSuccess (default: false): Get notified when process completes successfully
-  - notifyOnFailure (default: true): Get notified when process crashes/fails
-  - notifyOnKill (default: false): Get notified if killed by external signal (killing via tool never notifies)
+  - 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)
 - list: Show all managed processes with their IDs and names
 - output: Get recent stdout/stderr (requires 'id' - can be proc_N or name match)
 - logs: Get log file paths to inspect with read tool (requires 'id')
@@ -74,7 +74,7 @@ export function setupProcessesTools(pi: ExtensionAPI, manager: ProcessManager) {
 
 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 notifications in UI. Notification preferences only control whether YOU (the agent) are informed.`,
+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).`,
 
     parameters: ProcessesParams,
 
@@ -144,12 +144,15 @@ Note: User always sees notifications in UI. Notification preferences only contro
         const lines: string[] = [];
         lines.push(theme.fg("muted", details.message));
 
+        let hadAnsi = false;
+
         if (details.output.stdout.length > 0) {
           lines.push("");
           lines.push(theme.fg("accent", "stdout:"));
           const stdoutLines = details.output.stdout.slice(-20);
           for (const line of stdoutLines) {
-            lines.push(line);
+            if (!hadAnsi && hasAnsi(line)) hadAnsi = true;
+            lines.push(stripAnsi(line));
           }
           if (details.output.stdout.length > 20) {
             lines.push(
@@ -166,7 +169,8 @@ Note: User always sees notifications in UI. Notification preferences only contro
           lines.push(theme.fg("warning", "stderr:"));
           const stderrLines = details.output.stderr.slice(-10);
           for (const line of stderrLines) {
-            lines.push(theme.fg("warning", line));
+            if (!hadAnsi && hasAnsi(line)) hadAnsi = true;
+            lines.push(theme.fg("warning", stripAnsi(line)));
           }
           if (details.output.stderr.length > 10) {
             lines.push(
@@ -178,6 +182,13 @@ Note: User always sees notifications in UI. Notification preferences only contro
           }
         }
 
+        if (hadAnsi) {
+          lines.push("");
+          lines.push(
+            theme.fg("muted", "ANSI escape codes were stripped from output"),
+          );
+        }
+
         return new Text(lines.join("\n"), 0, 0);
       }