@pi-unipi/unipi 2.1.3 → 2.2.0

package/packages/memory/tui/settings-tui.ts

@@ -0,0 +1,281 @@
+/**
+ * @unipi/memory — Settings TUI
+ *
+ * Interactive settings dialog for embedding configuration.
+ * Uses ctx.ui primitives (select, input, notify).
+ */
+
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+  loadEmbeddingConfig,
+  saveEmbeddingConfig,
+  setApiKey,
+  clearApiKey,
+  getApiKey,
+  isEmbeddingReady,
+  hasModelChanged,
+  markModelUsed,
+  OPENROUTER_EMBEDDING_MODELS,
+  type EmbeddingConfig,
+} from "../settings.js";
+
+/**
+ * Show memory settings dialog.
+ * Main entry point for /unipi:memory-settings command.
+ */
+export async function showMemorySettings(ctx: ExtensionCommandContext): Promise<void> {
+  const ui = ctx.ui;
+  let running = true;
+
+  while (running) {
+    const config = loadEmbeddingConfig();
+    const hasKey = !!getApiKey();
+    const ready = isEmbeddingReady();
+
+    // Build status lines
+    const statusLines = [
+      `Provider: ${config.provider === "none" ? "None (fuzzy-only)" : "OpenRouter"}`,
+      `Model: ${config.model || "N/A"}`,
+      `Dimensions: ${config.dimensions}`,
+      `API Key: ${hasKey ? "✓ Set" : "✗ Not set"}`,
+      `Status: ${ready ? "✓ Ready" : "⚠ Not configured"}`,
+    ];
+
+    if (hasModelChanged() && !config.suppressMigrationWarning) {
+      statusLines.push("");
+      statusLines.push("⚠ Model changed — old embeddings incompatible.");
+      statusLines.push("  Re-embed to use vector search with new model.");
+    }
+
+    const options = [];
+
+    // API key management
+    if (hasKey) {
+      options.push({
+        label: "🔑 Update API Key",
+        value: "__update_key__",
+        description: "Update your OpenRouter API key",
+      });
+      options.push({
+        label: "🗑️ Remove API Key",
+        value: "__remove_key__",
+        description: "Remove API key and disable vector search",
+      });
+    } else {
+      options.push({
+        label: "🔑 Add API Key",
+        value: "__add_key__",
+        description: "Add OpenRouter API key to enable vector search",
+      });
+    }
+
+    // Model selection
+    options.push({
+      label: `📦 Select Model (current: ${config.model})`,
+      value: "__select_model__",
+      description: "Choose embedding model from OpenRouter",
+    });
+
+    // Dimensions
+    options.push({
+      label: `📐 Dimensions: ${config.dimensions}`,
+      value: "__dimensions__",
+      description: "Embedding dimensions (lower = faster, less storage)",
+    });
+
+    // Re-embed
+    if (ready && hasModelChanged()) {
+      options.push({
+        label: "🔄 Re-embed All Memories",
+        value: "__reembed__",
+        description: "Re-generate all embeddings with current model",
+      });
+    }
+
+    // Suppress warning
+    if (hasModelChanged() && !config.suppressMigrationWarning) {
+      options.push({
+        label: "🔕 Suppress Migration Warning",
+        value: "__suppress__",
+        description: "Hide the model change warning",
+      });
+    }
+
+    options.push({
+      label: "← Back",
+      value: "__exit__",
+      description: "Exit settings",
+    });
+
+    const labels = options.map(o => `${o.label} — ${o.description}`);
+    const selected = await ui.select(
+      "🧠 Memory Settings",
+      labels,
+    );
+    // Map selected label back to value
+    const selectedOpt = options.find(o => `${o.label} — ${o.description}` === selected);
+    const selectedValue = selectedOpt?.value;
+
+    if (!selectedValue || selectedValue === "__exit__") {
+      running = false;
+      continue;
+    }
+
+    switch (selectedValue) {
+      case "__add_key__":
+      case "__update_key__":
+        await handleApiKeyInput(ui);
+        break;
+      case "__remove_key__":
+        clearApiKey();
+        ui.notify("API key removed. Vector search disabled.", "info");
+        break;
+      case "__select_model__":
+        await handleModelSelection(ui);
+        break;
+      case "__dimensions__":
+        await handleDimensionsInput(ui);
+        break;
+      case "__reembed__":
+        await handleReembed(ui, ctx);
+        break;
+      case "__suppress__":
+        const cfg = loadEmbeddingConfig();
+        cfg.suppressMigrationWarning = true;
+        saveEmbeddingConfig(cfg);
+        ui.notify("Migration warning suppressed.", "info");
+        break;
+    }
+  }
+}
+
+/**
+ * Handle API key input.
+ */
+async function handleApiKeyInput(ui: ExtensionCommandContext["ui"]): Promise<void> {
+  const key = await ui.input(
+    "Enter your OpenRouter API key (sk-or-v1-...):",
+    "sk-or-v1-...",
+  );
+
+  if (key) {
+    const trimmed = key.trim();
+    if (trimmed.length === 0) {
+      ui.notify("API key cannot be empty.", "warning");
+      return;
+    }
+    if (!trimmed.startsWith("sk-or-") && !trimmed.startsWith("sk-")) {
+      ui.notify("Key should start with sk-or- or sk-.", "warning");
+      return;
+    }
+    setApiKey(trimmed);
+    ui.notify("API key saved. Vector search enabled.", "info");
+  }
+}
+
+/**
+ * Handle model selection.
+ */
+async function handleModelSelection(ui: ExtensionCommandContext["ui"]): Promise<void> {
+  const config = loadEmbeddingConfig();
+
+  const modelOptions = OPENROUTER_EMBEDDING_MODELS.map((m) => ({
+    label: `${m.name}${m.id === config.model ? " ✓" : ""}`,
+    value: m.id,
+    description: `${m.description} (${m.dimensions}d, ~${m.costPer1k}/1k tokens)`,
+  }));
+
+  // Add custom option
+  modelOptions.push({
+    label: "✏️ Custom Model ID",
+    value: "__custom__",
+    description: "Enter a custom OpenRouter model ID",
+  });
+
+  const labels = modelOptions.map(o => `${o.label} — ${o.description}`);
+  const selected = await ui.select(
+    "Select Embedding Model",
+    labels,
+  );
+
+  if (!selected) return;
+
+  // Map label back to value
+  const selectedOpt = modelOptions.find(o => `${o.label} — ${o.description}` === selected);
+  let modelId = selectedOpt?.value;
+
+  if (!modelId) return;
+
+  if (modelId === "__custom__") {
+    const custom = await ui.input(
+      "Enter the OpenRouter model ID:",
+      "openai/text-embedding-3-small",
+    );
+    if (!custom) return;
+    modelId = custom.trim();
+  }
+
+  // Find model info for dimensions
+  const modelInfo = OPENROUTER_EMBEDDING_MODELS.find((m) => m.id === modelId);
+  const dimensions = modelInfo?.dimensions ?? 384;
+
+  config.model = modelId;
+  config.dimensions = dimensions;
+  saveEmbeddingConfig(config);
+
+  ui.notify(
+    `Model set to ${modelId} (${dimensions}d).${hasModelChanged() ? " Re-embed existing memories to use new model." : ""}`,
+    "info",
+  );
+}
+
+/**
+ * Handle dimensions input.
+ */
+async function handleDimensionsInput(ui: ExtensionCommandContext["ui"]): Promise<void> {
+  const config = loadEmbeddingConfig();
+
+  const dimStr = await ui.input(
+    `Enter dimensions (default: 384). Lower = faster, less storage.\nNote: openai/text-embedding-3 supports 256-3072.\nada-002 only supports 1536.`,
+    "384",
+  );
+
+  if (dimStr) {
+    const dims = parseInt(dimStr, 10);
+    if (isNaN(dims) || dims < 64 || dims > 3072) {
+      ui.notify("Must be a number between 64 and 3072.", "warning");
+      return;
+    }
+    config.dimensions = dims;
+    saveEmbeddingConfig(config);
+
+    ui.notify(`Dimensions set to ${dims}. Re-embed existing memories to apply.`, "info");
+  }
+}
+
+/**
+ * Handle re-embedding all memories.
+ * This is a destructive operation — warns user first.
+ */
+async function handleReembed(ui: ExtensionCommandContext["ui"], ctx: ExtensionCommandContext): Promise<void> {
+  const confirmOptions = [
+    { label: "Yes, re-embed all — Proceed with re-embedding", value: "yes" },
+    { label: "Cancel — Abort", value: "no" },
+  ];
+  const confirmLabels = confirmOptions.map(o => o.label);
+  const confirm = await ui.select(
+    "Re-embed All Memories",
+    confirmLabels,
+  );
+
+  const confirmOpt = confirmOptions.find(o => o.label === confirm);
+  if (confirmOpt?.value !== "yes") return;
+
+  // Import here to avoid circular deps
+  const { reembedAllMemories } = await import("../embedding.js");
+  const count = await reembedAllMemories(ctx);
+
+  markModelUsed();
+
+  ui.notify(`Re-embedded ${count} memories with current model.`, "info");
+}

package/packages/milestone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/milestone",
-  "version": "2.1.3",
+  "version": "2.2.0",
   "description": "Lifecycle layer for project-level goals — MILESTONES.md tracking, session hooks, auto-sync",
   "type": "module",
   "main": "index.ts",
@@ -29,7 +29,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.1.3"
+    "@pi-unipi/core": "2.2.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

package/packages/notify/README.md

@@ -28,6 +28,8 @@ Notify subscribes to Pi lifecycle events and routes notifications based on your
 | `agent_settled` | Off | Agent fully settles after retries, compaction, and queued continuations |
 | `memory_consolidated` | Off | Memory auto-saved |
 | `session_shutdown` | Off | Session ends |
+| `ask_user_prompt` | Off | Agent asked a question and is waiting for an answer |
+| `permission_request` | Off | A permission prompt is about to be shown (requires [`@gotgenes/pi-permission-system`](https://www.npmjs.com/package/@gotgenes/pi-permission-system)) |
 
 Notify registers with the info-screen dashboard, showing enabled platforms and last notification time. The footer subscribes to `NOTIFICATION_SENT` events to display notification stats.
 

package/packages/notify/events.ts

@@ -14,6 +14,7 @@ import { sendGotifyNotification } from "./platforms/gotify.js";
 import { sendTelegramNotification } from "./platforms/telegram.js";
 import { sendNtfyNotification } from "./platforms/ntfy.js";
 import { buildAskUserPromptMessage } from "./ask-user-prompt-message.js";
+import { buildPermissionPromptMessage } from "./permission-prompt-message.js";
 import { summarizeLastMessage } from "./summarize.js";
 
 // Event emitted by @juicesharp/rpiv-ask-user-question before showing its UI.
@@ -21,6 +22,13 @@ import { summarizeLastMessage } from "./summarize.js";
 // `./events` contract in npm.
 const ASK_USER_PROMPT_EVENT = "rpiv:ask-user:prompt" as const;
 
+// Event emitted by @gotgenes/pi-permission-system immediately before the
+// user-facing permission UI is invoked. Fires only for prompts a human must
+// answer — policy auto-allow/deny and session approvals do not emit it.
+// Kept as a local string (like the rpiv event above) because it belongs to a
+// third-party package rather than the unipi event contract.
+const PERMISSION_UI_PROMPT_EVENT = "permissions:ui_prompt" as const;
+
 /** Stored session context for modelRegistry access */
 let sessionCtx: ExtensionContext | null = null;
 
@@ -58,6 +66,7 @@ export const BUILTIN_EVENTS: Record<
   memory_consolidated: { hook: UNIPI_EVENTS.MEMORY_CONSOLIDATED, label: "Memory Saved" },
   session_shutdown: { hook: "session_shutdown", label: "Session End" },
   ask_user_prompt: { hook: UNIPI_EVENTS.ASK_USER_PROMPT, label: "Question Asked" },
+  permission_request: { hook: PERMISSION_UI_PROMPT_EVENT, label: "Permission Request" },
 };
 
 /**
@@ -298,6 +307,8 @@ function buildEventMessage(eventKey: string, payload: unknown): string {
       return "Session ending";
     case "ask_user_prompt":
       return buildAskUserPromptMessage(payload);
+    case "permission_request":
+      return buildPermissionPromptMessage(payload);
     default:
       return p.message ? String(p.message) : "Event occurred";
   }

package/packages/notify/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/notify",
-  "version": "2.1.3",
+  "version": "2.2.0",
   "description": "Cross-platform notification extension for Pi — native OS, Gotify, and Telegram notifications for agent lifecycle events",
   "type": "module",
   "main": "index.ts",
@@ -42,7 +42,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "*",
+    "@pi-unipi/core": "2.2.0",
     "node-notifier": "^10.0.1"
   },
   "peerDependencies": {

package/packages/notify/permission-prompt-message.ts

@@ -0,0 +1,95 @@
+/**
+ * @pi-unipi/notify — Internal helper: build notification message from
+ * permission prompt event payloads.
+ *
+ * Handles the `permissions:ui_prompt` broadcast emitted by
+ * `@gotgenes/pi-permission-system` immediately before a human-facing
+ * permission prompt is shown.
+ *
+ * @internal — not part of the public API. Shared by the event listener and tests.
+ */
+
+export interface PermissionPromptEventPayload {
+  /** Correlation id for the permission request */
+  requestId?: string;
+  /** Originating subsystem of the request */
+  source?: string;
+  /** Surface being requested — e.g. "bash", "mcp", "read", "edit" */
+  surface?: string | null;
+  /** Command / path / tool / skill being requested */
+  value?: string | null;
+  /** Current or requesting agent, when available */
+  agentName?: string | null;
+  /** Human-readable permission prompt text */
+  message?: string;
+  /** Present for forwarded subagent prompts */
+  forwarding?: unknown;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object";
+}
+
+/** Return a trimmed non-empty string, or `undefined` for anything else. */
+function cleanString(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+/**
+ * `forwarding` is documented as "present for forwarded subagent prompts".
+ * Treat an explicitly falsy value (false / null / "" / 0) as not forwarded so
+ * that publishers which always include the key are handled correctly.
+ */
+function isForwarded(value: unknown): boolean {
+  if (value === undefined || value === null) return false;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "number") return value !== 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (isRecord(value)) return Object.keys(value).length > 0;
+  return true;
+}
+
+/**
+ * Build the "what was requested" clause from `agentName` / `surface` / `value`.
+ * Returns `undefined` when there is nothing meaningful to say.
+ */
+function buildRequestClause(
+  agentName: string | undefined,
+  surface: string | undefined,
+  value: string | undefined,
+): string | undefined {
+  if (!surface && !value) return undefined;
+
+  const who = agentName ?? "Agent";
+
+  if (surface && value) return `${who} requested ${surface} '${value}'.`;
+  if (surface) return `${who} requested ${surface} access.`;
+  return `${who} requested '${value}'.`;
+}
+
+/** Build a human-readable notification message from a permission prompt payload. */
+export function buildPermissionPromptMessage(payload: unknown): string {
+  const p = isRecord(payload) ? payload : {};
+
+  const agentName = cleanString(p.agentName);
+  const surface = cleanString(p.surface);
+  const value = cleanString(p.value);
+  const message = cleanString(p.message);
+
+  const parts: string[] = [];
+
+  const requestClause = buildRequestClause(agentName, surface, value);
+  if (requestClause) parts.push(requestClause);
+
+  // Only append the prompt text when it adds information beyond the clause.
+  if (message && message !== requestClause) parts.push(message);
+
+  if (parts.length === 0) parts.push("Pi is waiting for a permission decision.");
+
+  if (isForwarded(p.forwarding)) parts.push("(forwarded)");
+
+  return parts.join(" ");
+}

package/packages/notify/platforms/focus-win.ts

@@ -0,0 +1,123 @@
+/**
+ * @pi-unipi/notify — Windows focus detection
+ *
+ * Checks whether the terminal window is the foreground (active) window
+ * by walking the WMI process tree upward from the current process PID
+ * and comparing each ancestor against the foreground window's owner PID.
+ *
+ * This approach works reliably across cmd, PowerShell, and Windows
+ * Terminal, unlike GetConsoleWindow which returns NULL in spawned
+ * child processes.
+ *
+ * Requires PowerShell (built-in on Windows 7+).
+ */
+
+import { execFile } from "child_process";
+import { writeFileSync, rmSync, mkdtempSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// ---------------------------------------------------------------------------
+// PowerShell script (embedded)
+// ---------------------------------------------------------------------------
+
+const POWERCHECK_SCRIPT = `
+param($targetPid)
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+public class WinAPI {
+    [DllImport("user32.dll", SetLastError = false)]
+    public static extern IntPtr GetForegroundWindow();
+    [DllImport("user32.dll", SetLastError = false)]
+    public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
+}
+'@ | Out-Null
+$fgHwnd = [WinAPI]::GetForegroundWindow()
+[uint32]$fgPid = 0
+[void][WinAPI]::GetWindowThreadProcessId($fgHwnd, [ref]$fgPid)
+$curPid = $targetPid
+$maxDepth = 20
+while ($curPid -gt 0 -and $maxDepth-- -gt 0) {
+    if ($curPid -eq $fgPid) { Write-Host -NoNewline 'True'; exit }
+    $proc = Get-CimInstance -Class Win32_Process -Filter "ProcessId = $curPid" -ErrorAction SilentlyContinue | Select-Object -Property ParentProcessId
+    if (-not $proc) { break }
+    $curPid = $proc.ParentProcessId
+}
+Write-Host -NoNewline 'False'
+`;
+
+// ---------------------------------------------------------------------------
+// Cache — avoid spawning PowerShell on every check
+// ---------------------------------------------------------------------------
+
+let cached: { result: boolean; time: number } | null = null;
+const CACHE_TTL_MS = 500;
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true when the terminal window that owns the current process is
+ * the foreground (active) window on Windows.
+ *
+ * Works by:
+ *   1. Calling Win32 GetForegroundWindow + GetWindowThreadProcessId to
+ *      obtain the foreground window's owning PID.
+ *   2. Walking the WMI Win32_Process parent chain upward from
+ *      process.pid.
+ *   3. If any ancestor PID matches the foreground PID the terminal is
+ *      considered focused.
+ *
+ * The result is cached for 500 ms to avoid spawning PowerShell on rapid
+ * consecutive checks (e.g. batch notifications).
+ */
+export async function isWindowFocusedOnWindows(): Promise<boolean> {
+  const now = Date.now();
+  if (cached && now - cached.time < CACHE_TTL_MS) {
+    return cached.result;
+  }
+
+  let tmpDir: string | null = null;
+  try {
+    tmpDir = mkdtempSync(join(tmpdir(), "pi-focus-"));
+    const scriptPath = join(tmpDir, "check.ps1");
+    writeFileSync(scriptPath, POWERCHECK_SCRIPT, "utf-8");
+
+    const stdout = await new Promise<string>((resolve, reject) => {
+      execFile(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-ExecutionPolicy",
+          "Bypass",
+          "-File",
+          scriptPath,
+          String(process.pid),
+        ],
+        { timeout: 5000, encoding: "utf-8" },
+        (err, out) => {
+          if (err) reject(err);
+          else resolve(out);
+        }
+      );
+    });
+
+    cached = { result: stdout.trim() === "True", time: Date.now() };
+    return cached.result;
+  } catch {
+    // Detection failure → safe default: assume NOT focused (don't suppress)
+    cached = { result: false, time: Date.now() };
+    return false;
+  } finally {
+    if (tmpDir) {
+      try {
+        rmSync(tmpDir, { recursive: true });
+      } catch {
+        // Temp file cleanup is non-critical
+      }
+    }
+  }
+}

package/packages/notify/platforms/focus.ts

@@ -0,0 +1,33 @@
+/**
+ * @pi-unipi/notify — Focus detection abstraction
+ *
+ * Unified interface for checking whether the terminal window is the
+ * foreground (active) window. Platform-specific implementations are
+ * dispatched based on process.platform.
+ *
+ * Currently implemented:
+ *   - Windows (win32): calls focus-win.ts
+ *
+ * Unimplemented platforms always return false (no suppression).
+ */
+
+import { isWindowFocusedOnWindows } from "./focus-win.js";
+
+/**
+ * Check whether the current terminal/console window is the foreground
+ * (active) window. Used by sendNativeNotification to optionally
+ * suppress notifications when the user is already looking at the screen.
+ *
+ * @returns true if the terminal is the foreground window, false otherwise.
+ *          On unimplemented platforms, always returns false.
+ */
+export async function isWindowFocused(): Promise<boolean> {
+  switch (process.platform) {
+    case "win32":
+      return await isWindowFocusedOnWindows();
+    // TODO: macOS — use osascript to check frontmost application
+    // TODO: Linux — use xdotool (X11) or per-compositor tool (Wayland)
+    default:
+      return false;
+  }
+}

package/packages/notify/platforms/gotify.ts

@@ -0,0 +1,36 @@
+/**
+ * @pi-unipi/notify — Gotify notification platform
+ *
+ * Sends push notifications to a Gotify server via HTTP POST.
+ * Gotify is a self-hosted push notification server.
+ */
+
+/** Send a notification to Gotify server */
+export async function sendGotifyNotification(
+  serverUrl: string,
+  appToken: string,
+  title: string,
+  message: string,
+  priority: number = 5
+): Promise<void> {
+  const url = serverUrl.replace(/\/$/, "") + "/message";
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Gotify-Key": appToken,
+    },
+    body: JSON.stringify({
+      title,
+      message,
+      priority,
+    }),
+  });
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => "<no body>");
+    throw new Error(
+      `Gotify API error ${response.status}: ${body}`
+    );
+  }
+}