pi-extmgr 0.1.21 → 0.1.22

package/README.md

@@ -17,11 +17,16 @@ pi install npm:pi-extmgr
 
 Then reload Pi.
 
+Requires Node.js `>=22.5.0`.
+
 ## Features
 
 - **Unified manager UI**
   - Local extensions (`~/.pi/agent/extensions`, `.pi/extensions`) and installed packages in one list
   - Scope indicators (global/project), status indicators, update badges
+- **Package extension configuration panel**
+  - Configure individual extension entrypoints inside an installed package (`c` on package row)
+  - Persists to package filters in `settings.json` (no manual JSON editing)
 - **Safe staged local extension toggles**
   - Toggle with `Space/Enter`, apply with `S`
   - Unsaved-change guard when leaving (save/discard/stay)
@@ -54,22 +59,23 @@ Open the manager:
 
 ### In the manager
 
-| Key           | Action                                           |
-| ------------- | ------------------------------------------------ |
-| `↑↓`          | Navigate                                         |
-| `Space/Enter` | Toggle local/package extension on/off            |
-| `S`           | Save changes                                     |
-| `Enter` / `A` | Actions on selected package (update/remove/view) |
-| `u`           | Update selected package directly                 |
-| `X`           | Remove selected item (package/local extension)   |
-| `i`           | Quick install by source                          |
-| `f`           | Quick search                                     |
-| `U`           | Update all packages                              |
-| `t`           | Auto-update wizard                               |
-| `P` / `M`     | Quick actions palette                            |
-| `R`           | Browse remote packages                           |
-| `?` / `H`     | Help                                             |
-| `Esc`         | Exit                                             |
+| Key           | Action                                                |
+| ------------- | ----------------------------------------------------- |
+| `↑↓`          | Navigate                                              |
+| `Space/Enter` | Toggle local extension on/off                         |
+| `S`           | Save local extension changes                          |
+| `Enter` / `A` | Actions on selected package (configure/update/remove) |
+| `c`           | Configure selected package extensions                 |
+| `u`           | Update selected package directly                      |
+| `X`           | Remove selected item (package/local extension)        |
+| `i`           | Quick install by source                               |
+| `f`           | Quick search                                          |
+| `U`           | Update all packages                                   |
+| `t`           | Auto-update wizard                                    |
+| `P` / `M`     | Quick actions palette                                 |
+| `R`           | Browse remote packages                                |
+| `?` / `H`     | Help                                                  |
+| `Esc`         | Exit                                                  |
 
 ### Commands
 
@@ -134,7 +140,9 @@ Examples:
 
 ## Tips
 
-- **Staged changes**: Toggle extensions on/off, then press `S` to apply all at once. A `*` shows pending changes.
+- **Staged local changes**: Toggle local extensions on/off, then press `S` to apply all at once.
+- **Package extension config**: Select a package and press `c` (or Enter/A → Configure) to enable/disable individual package entrypoints.
+  - After saving package extension config, restart pi to fully apply changes.
 - **Two install modes**:
   - **Managed** (npm): Auto-updates with `pi update`, stored in pi's package cache
   - **Local** (standalone): Copies to `~/.pi/agent/extensions/{package}/`, supports multi-file extensions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-extmgr",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "Enhanced UX for managing local Pi extensions and community packages",
   "keywords": [
     "pi-package",
@@ -57,7 +57,7 @@
   "author": "ayagmar",
   "license": "MIT",
   "engines": {
-    "node": ">=22"
+    "node": ">=22.5.0"
   },
   "repository": {
     "type": "git",

package/src/packages/extensions.ts

@@ -1,9 +1,13 @@
-import { mkdir, readFile, writeFile, rename, rm } from "node:fs/promises";
-import { dirname, join, relative, resolve } from "node:path";
+import { mkdir, readFile, writeFile, rename, rm, readdir } from "node:fs/promises";
+import type { Dirent } from "node:fs";
+import { dirname, join, matchesGlob, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { getAgentDir } from "@mariozechner/pi-coding-agent";
 import type { InstalledPackage, PackageExtensionEntry, Scope, State } from "../types/index.js";
+import { parseNpmSource } from "../utils/format.js";
 import { fileExists, readSummary } from "../utils/fs.js";
 
 interface PackageSettingsObject {
@@ -15,6 +19,9 @@ interface SettingsFile {
   packages?: (string | PackageSettingsObject)[];
 }
 
+const execFileAsync = promisify(execFile);
+let globalNpmRootCache: string | null | undefined;
+
 function normalizeRelativePath(value: string): string {
   const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
   return normalized;
@@ -37,11 +44,69 @@ function normalizePackageRootCandidate(candidate: string): string {
   return resolved;
 }
 
-function toPackageRoot(pkg: InstalledPackage, cwd: string): string | undefined {
+async function getGlobalNpmRoot(): Promise<string | undefined> {
+  if (globalNpmRootCache !== undefined) {
+    return globalNpmRootCache ?? undefined;
+  }
+
+  try {
+    const { stdout } = await execFileAsync("npm", ["root", "-g"], {
+      timeout: 2_000,
+      windowsHide: true,
+    });
+    const root = stdout.trim();
+    globalNpmRootCache = root || null;
+  } catch {
+    globalNpmRootCache = null;
+  }
+
+  return globalNpmRootCache ?? undefined;
+}
+
+async function resolveNpmPackageRoot(
+  pkg: InstalledPackage,
+  cwd: string
+): Promise<string | undefined> {
+  const parsed = parseNpmSource(pkg.source);
+  if (!parsed?.name) {
+    return undefined;
+  }
+
+  const packageName = parsed.name;
+  const projectCandidates = [
+    join(cwd, ".pi", "npm", "node_modules", packageName),
+    join(cwd, "node_modules", packageName),
+  ];
+
+  const packageDir = process.env.PI_PACKAGE_DIR || join(homedir(), ".pi", "agent");
+  const globalCandidates = [join(packageDir, "npm", "node_modules", packageName)];
+
+  const npmGlobalRoot = await getGlobalNpmRoot();
+  if (npmGlobalRoot) {
+    globalCandidates.unshift(join(npmGlobalRoot, packageName));
+  }
+
+  const candidates =
+    pkg.scope === "project" ? projectCandidates : [...globalCandidates, ...projectCandidates];
+
+  for (const candidate of candidates) {
+    if (await fileExists(join(candidate, "package.json"))) {
+      return candidate;
+    }
+  }
+
+  return undefined;
+}
+
+async function toPackageRoot(pkg: InstalledPackage, cwd: string): Promise<string | undefined> {
   if (pkg.resolvedPath) {
     return normalizePackageRootCandidate(pkg.resolvedPath);
   }
 
+  if (pkg.source.startsWith("npm:")) {
+    return resolveNpmPackageRoot(pkg, cwd);
+  }
+
   if (pkg.source.startsWith("file://")) {
     try {
       return normalizePackageRootCandidate(fileURLToPath(pkg.source));
@@ -141,23 +206,79 @@ async function writeSettingsFile(path: string, settings: SettingsFile): Promise<
   }
 }
 
+function safeMatchesGlob(targetPath: string, pattern: string): boolean {
+  try {
+    return matchesGlob(targetPath, pattern);
+  } catch {
+    return false;
+  }
+}
+
+function matchesFilterPattern(targetPath: string, pattern: string): boolean {
+  const normalizedPattern = normalizeRelativePath(pattern.trim());
+  if (!normalizedPattern) return false;
+  if (targetPath === normalizedPattern) return true;
+
+  return safeMatchesGlob(targetPath, normalizedPattern);
+}
+
 function getPackageFilterState(filters: string[] | undefined, extensionPath: string): State {
-  if (!filters || filters.length === 0) {
+  // Omitted key => all enabled (pi default).
+  if (filters === undefined) {
     return "enabled";
   }
 
+  // Explicit empty array => load none.
+  if (filters.length === 0) {
+    return "disabled";
+  }
+
   const normalizedTarget = normalizeRelativePath(extensionPath);
-  let state: State = "enabled";
+  const includePatterns: string[] = [];
+  const excludePatterns: string[] = [];
+  let markerOverride: State | undefined;
+
+  for (const rawToken of filters) {
+    const token = rawToken.trim();
+    if (!token) continue;
+
+    const prefix = token[0];
+
+    if (prefix === "+" || prefix === "-") {
+      const markerPath = normalizeRelativePath(token.slice(1));
+      if (markerPath === normalizedTarget) {
+        markerOverride = prefix === "+" ? "enabled" : "disabled";
+      }
+      continue;
+    }
+
+    if (prefix === "!") {
+      const pattern = normalizeRelativePath(token.slice(1));
+      if (pattern) {
+        excludePatterns.push(pattern);
+      }
+      continue;
+    }
+
+    const include = normalizeRelativePath(token);
+    if (include) {
+      includePatterns.push(include);
+    }
+  }
+
+  let enabled =
+    includePatterns.length === 0 ||
+    includePatterns.some((p) => matchesFilterPattern(normalizedTarget, p));
+
+  if (enabled && excludePatterns.some((p) => matchesFilterPattern(normalizedTarget, p))) {
+    enabled = false;
+  }
 
-  for (const token of filters) {
-    if (!token || (token[0] !== "+" && token[0] !== "-")) continue;
-    const sign = token[0];
-    const path = normalizeRelativePath(token.slice(1));
-    if (path !== normalizedTarget) continue;
-    state = sign === "+" ? "enabled" : "disabled";
+  if (markerOverride !== undefined) {
+    enabled = markerOverride === "enabled";
   }
 
-  return state;
+  return enabled ? "enabled" : "disabled";
 }
 
 async function getPackageExtensionState(
@@ -185,26 +306,131 @@ async function getPackageExtensionState(
   return getPackageFilterState(entry.extensions, extensionPath);
 }
 
-async function discoverEntrypoints(packageRoot: string): Promise<string[]> {
+function isExtensionEntrypointPath(path: string): boolean {
+  return /\.(ts|js)$/i.test(path);
+}
+
+function hasGlobMagic(path: string): boolean {
+  return /[*?{}[\]]/.test(path);
+}
+
+function isSafeRelativePath(path: string): boolean {
+  return path !== "" && path !== ".." && !path.startsWith("../") && !path.includes("/../");
+}
+
+function selectDirectoryFiles(allFiles: string[], directoryPath: string): string[] {
+  const prefix = `${directoryPath}/`;
+  return allFiles.filter((file) => file.startsWith(prefix));
+}
+
+function applySelection(selected: Set<string>, files: Iterable<string>, exclude: boolean): void {
+  for (const file of files) {
+    if (exclude) {
+      selected.delete(file);
+    } else {
+      selected.add(file);
+    }
+  }
+}
+
+async function collectExtensionFilesFromDir(
+  packageRoot: string,
+  startDir: string
+): Promise<string[]> {
+  const collected: string[] = [];
+
+  let entries: Dirent[];
+  try {
+    entries = await readdir(startDir, { withFileTypes: true });
+  } catch {
+    return collected;
+  }
+
+  for (const entry of entries) {
+    const absolutePath = join(startDir, entry.name);
+
+    if (entry.isDirectory()) {
+      collected.push(...(await collectExtensionFilesFromDir(packageRoot, absolutePath)));
+      continue;
+    }
+
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    const relativePath = normalizeRelativePath(relative(packageRoot, absolutePath));
+    if (isExtensionEntrypointPath(relativePath)) {
+      collected.push(relativePath);
+    }
+  }
+
+  return collected;
+}
+
+async function resolveManifestExtensionEntries(
+  packageRoot: string,
+  entries: string[]
+): Promise<string[]> {
+  const selected = new Set<string>();
+  const allFiles = await collectExtensionFilesFromDir(packageRoot, packageRoot);
+
+  for (const rawToken of entries) {
+    const token = rawToken.trim();
+    if (!token) continue;
+
+    const exclude = token.startsWith("!");
+    const normalizedToken = normalizeRelativePath(exclude ? token.slice(1) : token);
+    const pattern = normalizedToken.replace(/[\\/]+$/g, "");
+    if (!isSafeRelativePath(pattern)) {
+      continue;
+    }
+
+    if (hasGlobMagic(pattern)) {
+      const matchedFiles = allFiles.filter((file) => matchesFilterPattern(file, pattern));
+      applySelection(selected, matchedFiles, exclude);
+      continue;
+    }
+
+    const directoryFiles = selectDirectoryFiles(allFiles, pattern);
+    if (directoryFiles.length > 0) {
+      applySelection(selected, directoryFiles, exclude);
+      continue;
+    }
+
+    if (isExtensionEntrypointPath(pattern)) {
+      applySelection(selected, [pattern], exclude);
+    }
+  }
+
+  return Array.from(selected).sort((a, b) => a.localeCompare(b));
+}
+
+export async function resolveManifestExtensionEntrypoints(
+  packageRoot: string
+): Promise<string[] | undefined> {
   const packageJsonPath = join(packageRoot, "package.json");
-  let manifestExtensions: string[] | undefined;
 
+  let parsed: { pi?: { extensions?: unknown } };
   try {
     const raw = await readFile(packageJsonPath, "utf8");
-    const parsed = JSON.parse(raw) as { pi?: { extensions?: unknown } };
-    const ext = parsed.pi?.extensions;
-    if (Array.isArray(ext)) {
-      const entries = ext.filter((value): value is string => typeof value === "string");
-      if (entries.length > 0) {
-        manifestExtensions = entries;
-      }
-    }
+    parsed = JSON.parse(raw) as { pi?: { extensions?: unknown } };
   } catch {
-    // Ignore invalid/missing package.json and fall back.
+    return undefined;
+  }
+
+  const extensions = parsed.pi?.extensions;
+  if (!Array.isArray(extensions)) {
+    return undefined;
   }
 
-  if (manifestExtensions && manifestExtensions.length > 0) {
-    return manifestExtensions.map((entry) => normalizeRelativePath(entry));
+  const entries = extensions.filter((value): value is string => typeof value === "string");
+  return resolveManifestExtensionEntries(packageRoot, entries);
+}
+
+async function discoverEntrypoints(packageRoot: string): Promise<string[]> {
+  const manifestEntrypoints = await resolveManifestExtensionEntrypoints(packageRoot);
+  if (manifestEntrypoints !== undefined) {
+    return manifestEntrypoints;
   }
 
   const indexTs = join(packageRoot, "index.ts");
@@ -227,7 +453,7 @@ export async function discoverPackageExtensions(
   const entries: PackageExtensionEntry[] = [];
 
   for (const pkg of packages) {
-    const packageRoot = toPackageRoot(pkg, cwd);
+    const packageRoot = await toPackageRoot(pkg, cwd);
     if (!packageRoot) continue;
 
     const extensionPaths = await discoverEntrypoints(packageRoot);
@@ -319,8 +545,3 @@ export async function setPackageExtensionState(
     };
   }
 }
-
-export function toProjectRelativePath(path: string, cwd: string): string {
-  const rel = relative(cwd, path);
-  return rel.startsWith("..") ? path : normalizeRelativePath(rel);
-}

package/src/packages/install.ts

@@ -1,13 +1,14 @@
 /**
  * Package installation logic
  */
-import { mkdir, rm, writeFile, cp, readFile } from "node:fs/promises";
+import { mkdir, rm, writeFile, cp } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
 import { normalizePackageSource } from "../utils/format.js";
 import { fileExists } from "../utils/fs.js";
 import { clearSearchCache, isSourceInstalled } from "./discovery.js";
+import { resolveManifestExtensionEntrypoints } from "./extensions.js";
 import { waitForCondition } from "../utils/retry.js";
 import { logPackageInstall } from "../utils/history.js";
 import { clearUpdatesAvailable } from "../utils/settings.js";
@@ -70,29 +71,15 @@ function safeExtractGithubMatch(match: RegExpMatchArray | null): GithubUrlInfo |
   return { owner, repo, branch, filePath };
 }
 
-function normalizeRelativePath(value: string): string {
-  return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
-}
-
 async function hasStandaloneEntrypoint(packageRoot: string): Promise<boolean> {
-  try {
-    const manifestPath = join(packageRoot, "package.json");
-    const raw = await readFile(manifestPath, "utf8");
-    const parsed = JSON.parse(raw) as { pi?: { extensions?: unknown } };
-    const declared = parsed.pi?.extensions;
-
-    if (Array.isArray(declared) && declared.length > 0) {
-      for (const entry of declared) {
-        if (typeof entry !== "string" || !entry.trim()) continue;
-        const candidate = join(packageRoot, normalizeRelativePath(entry));
-        if (await fileExists(candidate)) {
-          return true;
-        }
+  const declared = await resolveManifestExtensionEntrypoints(packageRoot);
+  if (declared !== undefined) {
+    for (const path of declared) {
+      if (await fileExists(join(packageRoot, path))) {
+        return true;
       }
-      return false;
     }
-  } catch {
-    // Ignore invalid/missing manifest and fall back to conventional entrypoints.
+    return false;
   }
 
   return (

package/src/packages/management.ts

@@ -10,7 +10,7 @@ import {
   isSourceInstalled,
 } from "./discovery.js";
 import { waitForCondition } from "../utils/retry.js";
-import { formatInstalledPackageLabel, formatBytes, parseNpmSource } from "../utils/format.js";
+import { formatInstalledPackageLabel, parseNpmSource } from "../utils/format.js";
 import { getPackageSourceKind, splitGitRepoAndRef } from "../utils/package-source.js";
 import { logPackageUpdate, logPackageRemove } from "../utils/history.js";
 import { clearUpdatesAvailable } from "../utils/settings.js";
@@ -408,62 +408,6 @@ export async function promptRemove(ctx: ExtensionCommandContext, pi: ExtensionAP
   }
 }
 
-export async function showPackageActions(
-  pkg: InstalledPackage,
-  ctx: ExtensionCommandContext,
-  pi: ExtensionAPI
-): Promise<boolean> {
-  if (!requireUI(ctx, "Package actions")) {
-    console.log(`Package: ${pkg.name}`);
-    console.log(`Version: ${pkg.version || "unknown"}`);
-    console.log(`Source: ${pkg.source}`);
-    console.log(`Scope: ${pkg.scope}`);
-    return true;
-  }
-
-  const choice = await ctx.ui.select(pkg.name, [
-    `Remove ${pkg.name}`,
-    `Update ${pkg.name}`,
-    "View details",
-    "Back to manager",
-  ]);
-
-  if (!choice || choice.includes("Back")) {
-    return false;
-  }
-
-  const action = choice.startsWith("Remove")
-    ? "remove"
-    : choice.startsWith("Update")
-      ? "update"
-      : choice.includes("details")
-        ? "details"
-        : "back";
-
-  switch (action) {
-    case "remove": {
-      const outcome = await removePackageWithOutcome(pkg.source, ctx, pi);
-      return outcome.reloaded;
-    }
-    case "update": {
-      const outcome = await updatePackageWithOutcome(pkg.source, ctx, pi);
-      return outcome.reloaded;
-    }
-    case "details": {
-      const sizeStr = pkg.size !== undefined ? `\nSize: ${formatBytes(pkg.size)}` : "";
-      notify(
-        ctx,
-        `Name: ${pkg.name}\nVersion: ${pkg.version || "unknown"}\nSource: ${pkg.source}\nScope: ${pkg.scope}${sizeStr}`,
-        "info"
-      );
-      return showPackageActions(pkg, ctx, pi);
-    }
-    case "back":
-    default:
-      return false;
-  }
-}
-
 export async function showInstalledPackagesList(
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI

package/src/types/index.ts

@@ -47,11 +47,11 @@ export interface PackageExtensionEntry {
 }
 
 export interface UnifiedItem {
-  type: "local" | "package" | "package-extension";
+  type: "local" | "package";
   id: string;
   displayName: string;
   summary: string;
-  scope: Scope | "global" | "project";
+  scope: Scope;
   // Local extension fields
   state?: State | undefined;
   activePath?: string | undefined;
@@ -63,9 +63,6 @@ export interface UnifiedItem {
   description?: string | undefined;
   size?: number | undefined; // Package size in bytes
   updateAvailable?: boolean | undefined;
-  // Package extension fields
-  packageSource?: string | undefined;
-  extensionPath?: string | undefined;
 }
 
 export interface SearchCache {
@@ -82,7 +79,11 @@ export type UnifiedAction =
   | { type: "help" }
   | { type: "menu" }
   | { type: "quick"; action: "install" | "search" | "update-all" | "auto-update" }
-  | { type: "action"; itemId: string; action?: "menu" | "update" | "remove" | "details" };
+  | {
+      type: "action";
+      itemId: string;
+      action?: "menu" | "update" | "remove" | "details" | "configure";
+    };
 
 export type BrowseAction =
   | { type: "package"; name: string }

package/src/ui/footer.ts

@@ -14,10 +14,9 @@ export interface FooterState {
  */
 export function buildFooterState(items: UnifiedItem[]): FooterState {
   const hasLocals = items.some((i) => i.type === "local");
-  const hasPackageExtensions = items.some((i) => i.type === "package-extension");
 
   return {
-    hasToggleRows: hasLocals || hasPackageExtensions,
+    hasToggleRows: hasLocals,
     hasLocals,
     hasPackages: items.some((i) => i.type === "package"),
   };
@@ -33,10 +32,7 @@ export function getPendingToggleChangeCount(
     const item = byId.get(id);
     if (!item) continue;
 
-    if (
-      (item.type === "local" || item.type === "package-extension") &&
-      item.originalState !== state
-    ) {
+    if (item.type === "local" && item.originalState !== state) {
       count += 1;
     }
   }
@@ -54,6 +50,7 @@ export function buildFooterShortcuts(state: FooterState): string {
   if (state.hasToggleRows) parts.push("Space/Enter Toggle");
   if (state.hasToggleRows) parts.push("S Save");
   if (state.hasPackages) parts.push("Enter/A Actions");
+  if (state.hasPackages) parts.push("c Configure");
   if (state.hasPackages) parts.push("u Update");
   if (state.hasPackages || state.hasLocals) parts.push("X Remove");
 

package/src/ui/help.ts

@@ -17,6 +17,7 @@ export function showHelp(ctx: ExtensionCommandContext): void {
     "  Space/Enter  Toggle local extension enabled/disabled",
     "  S            Save changes to local extensions",
     "  Enter/A      Open actions for selected package",
+    "  c            Configure selected package extensions (restart required after save)",
     "  u            Update selected package",
     "  X            Remove selected item (package or local extension)",
     "  i            Quick install by source",