@aliou/pi-processes 0.4.3 → 0.4.5

package/README.md

@@ -8,29 +8,14 @@ Manage background processes from Pi. Start long-running commands (dev servers, b
 
 ## Installation
 
-Install via npm:
-
 ```bash
 pi install npm:@aliou/pi-processes
 ```
 
-Or via the pi-extensions package:
+Or from git:
 
 ```bash
-pi install git:github.com/aliou/pi-extensions
-```
-
-Or selectively in your `settings.json`:
-
-```json
-{
-  "packages": [
-    {
-      "source": "git:github.com/aliou/pi-extensions",
-      "extensions": ["extensions/processes"]
-    }
-  ]
-}
+pi install git:github.com/aliou/pi-processes
 ```
 
 ## Features

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@aliou/pi-processes",
-  "version": "0.4.3",
+  "version": "0.4.5",
+  "license": "MIT",
   "type": "module",
   "private": false,
   "keywords": [
@@ -11,11 +12,11 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/aliou/pi-extensions"
+    "url": "https://github.com/aliou/pi-processes"
   },
   "pi": {
     "extensions": [
-      "./index.ts"
+      "./src/index.ts"
     ],
     "video": "https://assets.aliou.me/pi-extensions/demos/pi-processes.mp4"
   },
@@ -23,21 +24,35 @@
     "access": "public"
   },
   "files": [
-    "*.ts",
-    "commands",
-    "components",
-    "constants",
-    "hooks",
-    "tools",
-    "utils",
+    "src",
     "README.md"
   ],
   "dependencies": {
-    "@sinclair/typebox": "^0.34.41",
-    "@aliou/pi-utils-settings": "0.4.0",
-    "@aliou/pi-utils-ui": "^0.1.0"
+    "@aliou/pi-utils-settings": "^0.4.0",
+    "@aliou/pi-utils-ui": "^0.1.0",
+    "@sinclair/typebox": "^0.34.41"
   },
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": ">=0.51.0"
+  },
+  "devDependencies": {
+    "@aliou/pi-evals": "^0.3.0",
+    "@biomejs/biome": "^2.3.13",
+    "@changesets/cli": "^2.27.11",
+    "@mariozechner/pi-ai": "0.52.7",
+    "@mariozechner/pi-coding-agent": "0.52.7",
+    "@mariozechner/pi-tui": "0.52.7",
+    "@types/node": "^25.0.10",
+    "husky": "^9.1.7",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check",
+    "format": "biome check --write",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "pnpm changeset publish"
   }
 }

package/src/index.ts

@@ -0,0 +1,27 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+const MARKER_DIR = join(homedir(), ".pi", "agent", "extensions", "migrations");
+const MARKER_FILE = join(MARKER_DIR, "processes-moved");
+
+export default async function (pi: ExtensionAPI) {
+  if (existsSync(MARKER_FILE)) return;
+
+  pi.on("session_start", async (_event, ctx) => {
+    if (existsSync(MARKER_FILE)) return;
+
+    if (ctx.hasUI) {
+      ctx.ui.notify(
+        "@aliou/pi-processes has moved to its own repo. " +
+          "Run: pi install npm:@aliou/pi-processes -- " +
+          "then remove it from the pi-extensions package config.",
+        "warning",
+      );
+    }
+
+    mkdirSync(MARKER_DIR, { recursive: true });
+    writeFileSync(MARKER_FILE, new Date().toISOString());
+  });
+}

package/commands/index.ts

@@ -1,334 +0,0 @@
-import type {
-  ExtensionAPI,
-  ExtensionCommandContext,
-  Theme,
-} from "@mariozechner/pi-coding-agent";
-import { LogStreamComponent } from "../components/log-stream-component";
-import { ProcessPickerComponent } from "../components/process-picker-component";
-import { ProcessesComponent } from "../components/processes-component";
-import { LIVE_STATUSES, type ProcessInfo } from "../constants";
-import type { ProcessManager } from "../manager";
-
-const LOG_STREAM_WIDGET_ID = "processes-log-stream";
-
-function runningProcessCompletions(manager: ProcessManager) {
-  return (prefix: string) => {
-    const processes = manager.list();
-    const lower = prefix.toLowerCase();
-    return processes
-      .filter(
-        (p) =>
-          LIVE_STATUSES.has(p.status) &&
-          (p.id.toLowerCase().startsWith(lower) ||
-            p.name.toLowerCase().startsWith(lower)),
-      )
-      .map((p) => ({
-        value: p.id,
-        label: p.id,
-        description: p.name,
-      }));
-  };
-}
-
-function allProcessCompletions(manager: ProcessManager) {
-  return (prefix: string) => {
-    const processes = manager.list();
-    const lower = prefix.toLowerCase();
-    return processes
-      .filter(
-        (p) =>
-          p.id.toLowerCase().startsWith(lower) ||
-          p.name.toLowerCase().startsWith(lower),
-      )
-      .map((p) => ({
-        value: p.id,
-        label: p.id,
-        description: p.name,
-      }));
-  };
-}
-
-export function setupProcessesCommands(
-  pi: ExtensionAPI,
-  manager: ProcessManager,
-): void {
-  let streamingProcessId: string | null = null;
-
-  // ── /process:list ──────────────────────────────────────────────────
-  // Registered first so it appears first in autocomplete.
-  pi.registerCommand("process:list", {
-    description: "View and manage background processes",
-    handler: async (_args, ctx) => {
-      if (!ctx.hasUI) {
-        ctx.ui.notify("/process:list requires interactive mode", "error");
-        return;
-      }
-
-      // If currently streaming, dismiss the stream widget and show the list.
-      if (streamingProcessId) {
-        ctx.ui.setWidget(LOG_STREAM_WIDGET_ID, undefined);
-        streamingProcessId = null;
-      }
-
-      const result = await ctx.ui.custom<string | null>(
-        (tui, theme, _keybindings, done) => {
-          return new ProcessesComponent(
-            tui,
-            theme,
-            (processId?: string) => {
-              if (processId) {
-                done(processId);
-              } else {
-                done(null);
-              }
-            },
-            manager,
-          );
-        },
-      );
-
-      // RPC fallback.
-      if (result === undefined) {
-        ctx.ui.notify("/process:list requires interactive mode", "info");
-        return;
-      }
-
-      // User dismissed with Escape/q.
-      if (result === null) {
-        return;
-      }
-
-      // User selected a process — start streaming its logs.
-      startStreaming(ctx.ui, manager, result);
-    },
-  });
-
-  // ── /process:stream [id|name] ──────────────────────────────────────
-  pi.registerCommand("process:stream", {
-    description: "Stream logs from a running process",
-    getArgumentCompletions: runningProcessCompletions(manager),
-    handler: async (args, ctx) => {
-      const arg = args.trim();
-
-      // Explicit argument: stream that process.
-      if (arg) {
-        const proc = manager.find(arg);
-        if (!proc) {
-          ctx.ui.notify(`Process not found: ${arg}`, "error");
-          return;
-        }
-        if (!LIVE_STATUSES.has(proc.status)) {
-          ctx.ui.notify(
-            `${proc.name} (${proc.id}) is not running (${proc.status})`,
-            "info",
-          );
-          return;
-        }
-        startStreaming(ctx.ui, manager, proc.id);
-        return;
-      }
-
-      // No argument + currently streaming: dismiss.
-      if (streamingProcessId) {
-        ctx.ui.setWidget(LOG_STREAM_WIDGET_ID, undefined);
-        streamingProcessId = null;
-        return;
-      }
-
-      // No argument + not streaming: pick from running processes.
-      const running = manager.list().filter((p) => LIVE_STATUSES.has(p.status));
-
-      // No running processes.
-      if (running.length === 0) {
-        ctx.ui.notify("No running processes", "info");
-        return;
-      }
-
-      // Single running process: auto-select.
-      if (running.length === 1 && running[0]) {
-        startStreaming(ctx.ui, manager, running[0].id);
-        return;
-      }
-
-      // Multiple running processes: show picker.
-      const processId = await pickProcess(
-        ctx,
-        manager,
-        "Select process to stream",
-        (p) => LIVE_STATUSES.has(p.status),
-      );
-      if (!processId) return;
-      startStreaming(ctx.ui, manager, processId);
-    },
-  });
-
-  // ── /process:logs [id|name] ────────────────────────────────────────
-  pi.registerCommand("process:logs", {
-    description: "Show log file paths for a process",
-    getArgumentCompletions: allProcessCompletions(manager),
-    handler: async (args, ctx) => {
-      const arg = args.trim();
-
-      let processId: string | undefined;
-
-      if (arg) {
-        const proc = manager.find(arg);
-        if (!proc) {
-          ctx.ui.notify(`Process not found: ${arg}`, "error");
-          return;
-        }
-        processId = proc.id;
-      } else {
-        // No argument: show picker.
-        processId = await pickProcess(ctx, manager, "Select process for logs");
-        if (!processId) return;
-      }
-
-      const logFiles = manager.getLogFiles(processId);
-      const proc = manager.get(processId);
-      if (!logFiles || !proc) {
-        ctx.ui.notify(`Process not found: ${processId}`, "error");
-        return;
-      }
-
-      ctx.ui.notify(
-        `${proc.name} (${proc.id})\nstdout: ${logFiles.stdoutFile}\nstderr: ${logFiles.stderrFile}`,
-        "info",
-      );
-    },
-  });
-
-  // ── /process:kill [id|name] ────────────────────────────────────────
-  pi.registerCommand("process:kill", {
-    description: "Kill a running background process",
-    getArgumentCompletions: runningProcessCompletions(manager),
-    handler: async (args, ctx) => {
-      const arg = args.trim();
-
-      let processId: string | undefined;
-
-      if (arg) {
-        const proc = manager.find(arg);
-        if (!proc) {
-          ctx.ui.notify(`Process not found: ${arg}`, "error");
-          return;
-        }
-        if (!LIVE_STATUSES.has(proc.status)) {
-          ctx.ui.notify(
-            `${proc.name} (${proc.id}) is not running (${proc.status})`,
-            "info",
-          );
-          return;
-        }
-        processId = proc.id;
-      } else {
-        // No argument: show picker (only running processes).
-        const running = manager
-          .list()
-          .filter((p) => LIVE_STATUSES.has(p.status));
-
-        if (running.length === 0) {
-          ctx.ui.notify("No running processes to kill", "info");
-          return;
-        }
-
-        if (running.length === 1 && running[0]) {
-          processId = running[0].id;
-        } else {
-          processId = await pickProcess(
-            ctx,
-            manager,
-            "Select process to kill",
-            (p) => LIVE_STATUSES.has(p.status),
-          );
-          if (!processId) return;
-        }
-      }
-
-      const proc = manager.get(processId);
-      if (!proc) {
-        ctx.ui.notify(`Process not found: ${processId}`, "error");
-        return;
-      }
-
-      const signal =
-        proc.status === "terminate_timeout" ? "SIGKILL" : "SIGTERM";
-      const timeoutMs = signal === "SIGKILL" ? 200 : 3000;
-      const result = await manager.kill(processId, { signal, timeoutMs });
-
-      if (result.ok) {
-        ctx.ui.notify(`Killed ${proc.name} (${proc.id})`, "info");
-      } else {
-        ctx.ui.notify(
-          `Failed to kill ${proc.name} (${proc.id}): ${result.reason}`,
-          "error",
-        );
-      }
-    },
-  });
-
-  // ── /process:clear ─────────────────────────────────────────────────
-  pi.registerCommand("process:clear", {
-    description: "Clear finished processes",
-    handler: async (_args, ctx) => {
-      const cleared = manager.clearFinished();
-      if (cleared > 0) {
-        ctx.ui.notify(
-          `Cleared ${cleared} finished process${cleared > 1 ? "es" : ""}`,
-          "info",
-        );
-      } else {
-        ctx.ui.notify("No finished processes to clear", "info");
-      }
-    },
-  });
-
-  // ── Helpers ────────────────────────────────────────────────────────
-
-  function startStreaming(
-    ui: ExtensionCommandContext["ui"],
-    mgr: ProcessManager,
-    processId: string,
-  ) {
-    streamingProcessId = processId;
-    ui.setWidget(
-      LOG_STREAM_WIDGET_ID,
-      (tui: { requestRender: () => void }, theme: Theme) => {
-        return new LogStreamComponent(tui, theme, mgr, processId);
-      },
-      { placement: "aboveEditor" },
-    );
-  }
-}
-
-async function pickProcess(
-  ctx: ExtensionCommandContext,
-  manager: ProcessManager,
-  title: string,
-  filter?: (proc: ProcessInfo) => boolean,
-): Promise<string | undefined> {
-  if (!ctx.hasUI) {
-    ctx.ui.notify("Interactive mode required", "error");
-    return undefined;
-  }
-
-  const result = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
-    return new ProcessPickerComponent(
-      tui,
-      theme,
-      (processId?: string) => {
-        done(processId ?? null);
-      },
-      manager,
-      title,
-      filter,
-    );
-  });
-
-  // RPC fallback or user cancelled.
-  if (result === undefined || result === null) {
-    return undefined;
-  }
-
-  return result;
-}

package/commands/settings-command.ts

@@ -1,128 +0,0 @@
-import {
-  registerSettingsCommand,
-  type SettingsSection,
-} from "@aliou/pi-utils-settings";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import type { ProcessesConfig, ResolvedProcessesConfig } from "../config";
-import { configLoader } from "../config";
-
-export function registerProcessesSettings(
-  pi: ExtensionAPI,
-  onSave?: () => void,
-): void {
-  registerSettingsCommand<ProcessesConfig, ResolvedProcessesConfig>(pi, {
-    commandName: "process:settings",
-    title: "Processes Settings",
-    configStore: configLoader,
-    buildSections: (
-      tabConfig: ProcessesConfig | null,
-      resolved: ResolvedProcessesConfig,
-    ): SettingsSection[] => {
-      return [
-        {
-          label: "Process List",
-          items: [
-            {
-              id: "processList.maxVisibleProcesses",
-              label: "Max visible processes",
-              description:
-                "Maximum processes shown in the /processes list before scrolling",
-              currentValue: String(
-                tabConfig?.processList?.maxVisibleProcesses ??
-                  resolved.processList.maxVisibleProcesses,
-              ),
-              values: ["4", "6", "8", "12", "16"],
-            },
-            {
-              id: "processList.maxPreviewLines",
-              label: "Max preview lines",
-              description: "Log preview lines shown below the selected process",
-              currentValue: String(
-                tabConfig?.processList?.maxPreviewLines ??
-                  resolved.processList.maxPreviewLines,
-              ),
-              values: ["6", "8", "12", "16", "24"],
-            },
-          ],
-        },
-        {
-          label: "Output Limits",
-          items: [
-            {
-              id: "output.defaultTailLines",
-              label: "Default tail lines",
-              description:
-                "Number of tail lines returned to the agent by default",
-              currentValue: String(
-                tabConfig?.output?.defaultTailLines ??
-                  resolved.output.defaultTailLines,
-              ),
-              values: ["50", "100", "200", "500"],
-            },
-            {
-              id: "output.maxOutputLines",
-              label: "Max output lines",
-              description: "Hard cap on output lines returned to the agent",
-              currentValue: String(
-                tabConfig?.output?.maxOutputLines ??
-                  resolved.output.maxOutputLines,
-              ),
-              values: ["100", "200", "500", "1000"],
-            },
-          ],
-        },
-        {
-          label: "Widget",
-          items: [
-            {
-              id: "widget.showStatusWidget",
-              label: "Show status widget",
-              description: "Show process status widget below the editor",
-              currentValue:
-                (tabConfig?.widget?.showStatusWidget ??
-                resolved.widget.showStatusWidget)
-                  ? "on"
-                  : "off",
-              values: ["on", "off"],
-            },
-          ],
-        },
-      ];
-    },
-    onSettingChange: (id, newValue, config) => {
-      const updated = structuredClone(config);
-      // Boolean fields.
-      if (id === "widget.showStatusWidget") {
-        if (!updated.widget) updated.widget = {};
-        updated.widget.showStatusWidget = newValue === "on";
-        return updated;
-      }
-      // Numeric fields.
-      const num = Number.parseInt(newValue, 10);
-      if (Number.isNaN(num)) return null;
-
-      switch (id) {
-        case "processList.maxVisibleProcesses":
-          if (!updated.processList) updated.processList = {};
-          updated.processList.maxVisibleProcesses = num;
-          break;
-        case "processList.maxPreviewLines":
-          if (!updated.processList) updated.processList = {};
-          updated.processList.maxPreviewLines = num;
-          break;
-        case "output.defaultTailLines":
-          if (!updated.output) updated.output = {};
-          updated.output.defaultTailLines = num;
-          break;
-        case "output.maxOutputLines":
-          if (!updated.output) updated.output = {};
-          updated.output.maxOutputLines = num;
-          break;
-        default:
-          return null;
-      }
-      return updated;
-    },
-    onSave,
-  });
-}