pi-extmgr 0.1.28 → 0.2.0

package/README.md

@@ -18,25 +18,29 @@ pi install npm:pi-extmgr
 
 If Pi is already running, use `/reload`.
 
-Requires Node.js `>=22`.
+Requires Node.js `>=22.20.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
+  - Grouped sections for local extensions vs installed packages
+  - Compact rows with selected-item details below the list, so large extension sets stay scannable
+  - Built-in search and filter shortcuts for large extension sets
+  - Scope indicators (global/project), status indicators, update badges, and package sizes when known
 - **Package extension configuration panel**
   - Configure individual extension entrypoints inside an installed package (`c` on package row)
   - Works with manifest-declared entrypoints and conventional `extensions/` package layouts
   - Persists to package filters in `settings.json` (no manual JSON editing)
 - **Safe staged local extension toggles**
-  - Toggle with `Space/Enter`, apply with `S`
+  - Toggle with `Space`, apply with `S`
   - Unsaved-change guard when leaving (save/discard/stay)
 - **Package management**
   - Install, update, remove from UI and command line
   - Quick actions (`A`, `u`, `X`) and bulk update (`U`)
 - **Remote discovery and install**
-  - npm search/browse with pagination
+  - npm search/browse with pagination, inline browse search, and keyboard page navigation
+  - Path- and git-like queries are handled explicitly instead of surfacing unrelated npm results
   - Install by source (`npm:`, `git:`, `https://`, `ssh://`, `git@...`, local path)
   - Supports direct GitHub `.ts` installs and standalone local install for self-contained packages
   - Long-running discovery/detail screens now show dedicated loading UI, and cancellable reads can be aborted with `Esc`
@@ -66,20 +70,26 @@ Open the manager:
 | Key           | Action                                                |
 | ------------- | ----------------------------------------------------- |
 | `↑↓`          | Navigate                                              |
-| `Space/Enter` | Toggle local extension on/off                         |
+| `PageUp/Down` | Jump through longer lists                             |
+| `Home/End`    | Jump to top or bottom                                 |
+| `Space`       | Toggle selected local extension on/off                |
 | `S`           | Save local extension changes                          |
-| `Enter` / `A` | Actions on selected package (configure/update/remove) |
+| `Enter` / `A` | Actions on selected item                              |
+| `/` / `Ctrl+F`| Search visible items                                  |
+| `Tab` / `Shift+Tab` | Cycle filters                                  |
+| `1-5`         | Filters: All / Local / Packages / Updates / Disabled  |
 | `c`           | Configure selected package extensions                 |
 | `u`           | Update selected package directly                      |
+| `V`           | View full details for selected item                   |
 | `X`           | Remove selected item (package/local extension)        |
 | `i`           | Quick install by source                               |
-| `f`           | Quick search                                          |
+| `f`           | Remote package search                                 |
 | `U`           | Update all packages                                   |
 | `t`           | Auto-update wizard                                    |
 | `P` / `M`     | Quick actions palette                                 |
 | `R`           | Browse remote packages                                |
 | `?` / `H`     | Help                                                  |
-| `Esc`         | Exit                                                  |
+| `Esc`         | Clear search or exit                                  |
 
 ### Commands
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-extmgr",
-  "version": "0.1.28",
+  "version": "0.2.0",
   "description": "Enhanced UX for managing local Pi extensions and community packages",
   "keywords": [
     "pi-package",
@@ -27,6 +27,12 @@
     "smoke-test": "node --import=tsx ./scripts/smoke-test.mjs",
     "test": "node --import=tsx --test ./test/*.test.ts",
     "check": "tsc --noEmit -p tsconfig.json && node --import=tsx ./scripts/smoke-test.mjs && node --import=tsx --test ./test/*.test.ts && pnpm run lint && pnpm run format:check",
+    "release": "release-it",
+    "release:patch": "release-it patch",
+    "release:minor": "release-it minor",
+    "release:major": "release-it major",
+    "release:first": "release-it --first-release",
+    "release:ci": "node --import=tsx ./scripts/release-ci.ts",
     "prepublishOnly": "pnpm run check",
     "prepare": "husky"
   },
@@ -45,8 +51,10 @@
     "@biomejs/biome": "^2.4.9",
     "@mariozechner/pi-coding-agent": "^0.63.1",
     "@mariozechner/pi-tui": "^0.63.1",
+    "@release-it/conventional-changelog": "^10.0.5",
     "@types/node": "^22.19.10",
     "husky": "^9.1.7",
+    "release-it": "^19.2.4",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
@@ -54,7 +62,7 @@
   "license": "MIT",
   "packageManager": "pnpm@10.33.0",
   "engines": {
-    "node": ">=22"
+    "node": ">=22.20.0"
   },
   "repository": {
     "type": "git",

package/src/commands/auto-update.ts

@@ -54,7 +54,7 @@ export async function handleAutoUpdateSubcommand(
       "  3d      - Check every 3 days",
       "  1w      - Check weekly",
       "  2w      - Check every 2 weeks",
-      "  1mo     - Check monthly (1m also works)",
+      "  1mo     - Check monthly",
       "  daily   - Check daily (alias)",
       "  weekly  - Check weekly (alias)",
     ];

package/src/commands/history.ts

@@ -6,6 +6,7 @@ import {
   queryGlobalHistory,
   querySessionChanges,
 } from "../utils/history.js";
+import { parseLookbackDuration } from "../utils/duration.js";
 import { notify } from "../utils/notify.js";
 import { formatListOutput } from "../utils/ui-helpers.js";
 
@@ -37,36 +38,6 @@ type HistoryOptionHandler = (tokens: string[], index: number, state: HistoryPars
 
 const HISTORY_ACTION_SET = new Set<ChangeAction>(HISTORY_ACTIONS);
 
-function parseHistorySinceDuration(input: string): number | undefined {
-  const normalized = input.toLowerCase().trim();
-  const match = normalized.match(
-    /^(\d+)\s*(m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days|w|wk|wks|week|weeks|mo|mos|month|months)$/
-  );
-  if (!match) return undefined;
-
-  const value = Number.parseInt(match[1] ?? "", 10);
-  if (!Number.isFinite(value) || value <= 0) return undefined;
-
-  const unit = match[2] ?? "";
-  if (unit.startsWith("m") && !unit.startsWith("mo")) {
-    return value * 60 * 1000;
-  }
-  if (unit.startsWith("h")) {
-    return value * 60 * 60 * 1000;
-  }
-  if (unit.startsWith("d")) {
-    return value * 24 * 60 * 60 * 1000;
-  }
-  if (unit.startsWith("w")) {
-    return value * 7 * 24 * 60 * 60 * 1000;
-  }
-  if (unit.startsWith("mo")) {
-    return value * 30 * 24 * 60 * 60 * 1000;
-  }
-
-  return undefined;
-}
-
 const HISTORY_OPTION_HANDLERS: Record<string, HistoryOptionHandler> = {
   "--help": (_tokens, _index, state) => {
     state.showHelp = true;
@@ -142,7 +113,7 @@ const HISTORY_OPTION_HANDLERS: Record<string, HistoryOptionHandler> = {
       return 0;
     }
 
-    const ms = parseHistorySinceDuration(value);
+    const ms = parseLookbackDuration(value);
     if (!ms) {
       state.errors.push(`Invalid --since duration: ${value}`);
     } else {

package/src/constants.ts

@@ -26,14 +26,6 @@ export const TIMEOUTS = {
   npmView: 10_000,
   /** Full package installation timeout (3 minutes) */
   packageInstall: 180_000,
-  /** Package update timeout (2 minutes) */
-  packageUpdate: 120_000,
-  /** Bulk package update timeout (5 minutes) */
-  packageUpdateAll: 300_000,
-  /** Package removal timeout (1 minute) */
-  packageRemove: 60_000,
-  /** Package listing timeout */
-  listPackages: 10_000,
   /** Package metadata fetch timeout */
   fetchPackageInfo: 30_000,
   /** Package extraction timeout */

package/src/extensions/discovery.ts

@@ -10,8 +10,13 @@ import { readdir, rename, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, join, relative } from "node:path";
 import { DISABLED_SUFFIX } from "../constants.js";
+import { readPackageManifest } from "../packages/extensions.js";
 import { type ExtensionEntry, type Scope, type State } from "../types/index.js";
 import { fileExists, readSummary } from "../utils/fs.js";
+import {
+  normalizeRelativePath,
+  resolveRelativePathSelection,
+} from "../utils/relative-path-selection.js";
 
 interface RootConfig {
   root: string;
@@ -94,8 +99,7 @@ async function discoverInRoot(
     }
 
     if (item.isDirectory()) {
-      const entry = await parseDirectoryIndex(root, label, scope, name);
-      if (entry) found.push(entry);
+      found.push(...(await parseDirectoryExtensions(root, label, scope, name)));
     }
   }
 
@@ -141,53 +145,131 @@ async function parseTopLevelFile(
   };
 }
 
+function stripDisabledSuffix(path: string): string {
+  return path.replace(/\.(ts|js)\.disabled$/i, ".$1");
+}
+
+function isExtensionEntrypointPath(path: string): boolean {
+  return /\.(ts|js)$/i.test(path);
+}
+
+function isLocalExtensionFile(path: string): boolean {
+  return /\.(ts|js)(?:\.disabled)?$/i.test(path);
+}
+
+async function collectLocalExtensionFiles(rootDir: 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) {
+    if (entry.name.startsWith(".")) {
+      continue;
+    }
+
+    const absolutePath = join(startDir, entry.name);
+    if (entry.isDirectory()) {
+      collected.push(...(await collectLocalExtensionFiles(rootDir, absolutePath)));
+      continue;
+    }
+
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    const relativePath = normalizeRelativePath(relative(rootDir, absolutePath));
+    if (isLocalExtensionFile(relativePath)) {
+      collected.push(stripDisabledSuffix(relativePath));
+    }
+  }
+
+  return collected;
+}
+
+async function resolveManifestLocalEntrypoints(dir: string): Promise<string[] | undefined> {
+  const manifest = await readPackageManifest(dir);
+  const extensions = manifest?.pi?.extensions;
+  if (!Array.isArray(extensions)) {
+    return undefined;
+  }
+
+  const entries = extensions.filter((value): value is string => typeof value === "string");
+  const allFiles = await collectLocalExtensionFiles(dir, dir);
+  return resolveRelativePathSelection(
+    allFiles,
+    entries,
+    (path, files) => isExtensionEntrypointPath(path) && files.includes(path)
+  );
+}
+
+async function toDirectoryExtensionEntry(
+  root: string,
+  label: string,
+  scope: Scope,
+  dir: string,
+  extensionPath: string
+): Promise<ExtensionEntry | undefined> {
+  const normalizedPath = normalizeRelativePath(extensionPath);
+  const activePath = join(dir, normalizedPath);
+  const disabledPath = `${activePath}${DISABLED_SUFFIX}`;
+
+  let state: State;
+  let summaryPath: string;
+  if (await fileExists(activePath)) {
+    state = "enabled";
+    summaryPath = activePath;
+  } else if (await fileExists(disabledPath)) {
+    state = "disabled";
+    summaryPath = disabledPath;
+  } else {
+    return undefined;
+  }
+
+  return {
+    id: `${scope}:${activePath}`,
+    scope,
+    state,
+    activePath,
+    disabledPath,
+    displayName: `${label}/${normalizeRelativePath(relative(root, activePath))}`,
+    summary: await readSummary(summaryPath),
+  };
+}
+
 /**
- * Parse a directory containing an index.ts/js file as an extension entry.
- *
- * @param root - Root directory path
- * @param label - Display label for the root
- * @param scope - "global" or "project"
- * @param dirName - Name of the directory to parse
- * @returns ExtensionEntry if index file found, undefined otherwise
+ * Parse a directory containing a manifest-declared entrypoint or index.ts/js file as one or more
+ * extension entries.
  */
-async function parseDirectoryIndex(
+async function parseDirectoryExtensions(
   root: string,
   label: string,
   scope: Scope,
   dirName: string
-): Promise<ExtensionEntry | undefined> {
+): Promise<ExtensionEntry[]> {
   const dir = join(root, dirName);
+  const manifestEntrypoints = await resolveManifestLocalEntrypoints(dir);
 
-  for (const ext of [".ts", ".js"]) {
-    const activePath = join(dir, `index${ext}`);
-    const disabledPath = `${activePath}${DISABLED_SUFFIX}`;
-
-    if (await fileExists(activePath)) {
-      return {
-        id: `${scope}:${activePath}`,
-        scope,
-        state: "enabled",
-        activePath,
-        disabledPath,
-        displayName: `${label}/${dirName}/index${ext}`,
-        summary: await readSummary(activePath),
-      };
-    }
-
-    if (await fileExists(disabledPath)) {
-      return {
-        id: `${scope}:${activePath}`,
-        scope,
-        state: "disabled",
-        activePath,
-        disabledPath,
-        displayName: `${label}/${dirName}/index${ext}`,
-        summary: await readSummary(disabledPath),
-      };
-    }
+  if (manifestEntrypoints !== undefined) {
+    const entries = await Promise.all(
+      manifestEntrypoints.map((extensionPath) =>
+        toDirectoryExtensionEntry(root, label, scope, dir, extensionPath)
+      )
+    );
+    return entries.filter((entry): entry is ExtensionEntry => Boolean(entry));
   }
 
-  return undefined;
+  const fallbackEntries = await Promise.all(
+    ["index.ts", "index.js"].map((extensionPath) =>
+      toDirectoryExtensionEntry(root, label, scope, dir, extensionPath)
+    )
+  );
+
+  return fallbackEntries.filter((entry): entry is ExtensionEntry => Boolean(entry)).slice(0, 1);
 }
 
 /**

package/src/packages/discovery.ts

@@ -28,6 +28,14 @@ interface NpmSearchResultObject {
     description?: string;
     keywords?: string[];
     date?: string;
+    publisher?: {
+      username?: string;
+      email?: string;
+    };
+    maintainers?: Array<{
+      username?: string;
+      email?: string;
+    }>;
   };
 }
 
@@ -79,6 +87,31 @@ import {
   setCachedSearch,
 } from "../utils/cache.js";
 
+function getNpmPackageAuthor(
+  pkg: NonNullable<NpmSearchResultObject["package"]>
+): string | undefined {
+  const publisher = pkg.publisher;
+  if (publisher?.username?.trim()) {
+    return publisher.username.trim();
+  }
+
+  if (publisher?.email?.trim()) {
+    return publisher.email.trim();
+  }
+
+  const maintainerWithUsername = pkg.maintainers?.find((entry) => entry.username?.trim());
+  if (maintainerWithUsername?.username?.trim()) {
+    return maintainerWithUsername.username.trim();
+  }
+
+  const maintainerWithEmail = pkg.maintainers?.find((entry) => entry.email?.trim());
+  if (maintainerWithEmail?.email?.trim()) {
+    return maintainerWithEmail.email.trim();
+  }
+
+  return undefined;
+}
+
 function toNpmPackage(entry: NpmSearchResultObject): NpmPackage | undefined {
   const pkg = entry.package;
   if (!pkg) return undefined;
@@ -90,6 +123,7 @@ function toNpmPackage(entry: NpmSearchResultObject): NpmPackage | undefined {
     name,
     version: pkg.version,
     description: pkg.description,
+    author: getNpmPackageAuthor(pkg),
     keywords: Array.isArray(pkg.keywords) ? pkg.keywords : undefined,
     date: pkg.date,
   };

package/src/packages/extensions.ts

@@ -2,7 +2,7 @@ import { execFile } from "node:child_process";
 import { type Dirent } from "node:fs";
 import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join, matchesGlob, relative, resolve } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { getAgentDir } from "@mariozechner/pi-coding-agent";
@@ -14,6 +14,11 @@ import {
 } from "../types/index.js";
 import { parseNpmSource } from "../utils/format.js";
 import { fileExists, readSummary } from "../utils/fs.js";
+import {
+  matchesFilterPattern,
+  normalizeRelativePath,
+  resolveRelativePathSelection,
+} from "../utils/relative-path-selection.js";
 import { resolveNpmCommand } from "../utils/npm-exec.js";
 
 interface PackageSettingsObject {
@@ -36,11 +41,6 @@ export interface PackageManifest {
 const execFileAsync = promisify(execFile);
 let globalNpmRootCache: string | null | undefined;
 
-function normalizeRelativePath(value: string): string {
-  const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
-  return normalized;
-}
-
 function normalizeSource(source: string): string {
   return source
     .trim()
@@ -238,17 +238,17 @@ function toPackageSettingsObject(
   packageSource: string
 ): PackageSettingsObject {
   if (typeof existing === "string") {
-    return { source: existing, extensions: [] };
+    return { source: existing };
   }
 
   if (existing && typeof existing.source === "string") {
     return {
       source: existing.source,
-      extensions: Array.isArray(existing.extensions) ? [...existing.extensions] : [],
+      ...(Array.isArray(existing.extensions) ? { extensions: [...existing.extensions] } : {}),
     };
   }
 
-  return { source: packageSource, extensions: [] };
+  return { source: packageSource };
 }
 
 function updateExtensionMarkers(
@@ -276,7 +276,16 @@ function updateExtensionMarkers(
   for (const [extensionPath, target] of Array.from(changes.entries()).sort((a, b) =>
     a[0].localeCompare(b[0])
   )) {
-    nextTokens.push(`${target === "enabled" ? "+" : "-"}${extensionPath}`);
+    const baseFilters =
+      nextTokens.length > 0
+        ? nextTokens
+        : existingTokens && existingTokens.length === 0
+          ? []
+          : undefined;
+    const baseState = getPackageFilterState(baseFilters, extensionPath);
+    if (target !== baseState) {
+      nextTokens.push(`${target === "enabled" ? "+" : "-"}${extensionPath}`);
+    }
   }
 
   return nextTokens;
@@ -322,10 +331,13 @@ export async function applyPackageExtensionStateChanges(
 
     packageEntry.extensions = updateExtensionMarkers(packageEntry.extensions, normalizedChanges);
 
+    const normalizedPackageEntry =
+      packageEntry.extensions.length > 0 ? packageEntry : packageEntry.source;
+
     if (index === -1) {
-      packages.push(packageEntry);
+      packages.push(normalizedPackageEntry);
     } else {
-      packages[index] = packageEntry;
+      packages[index] = normalizedPackageEntry;
     }
 
     settings.packages = packages;
@@ -340,22 +352,6 @@ export async function applyPackageExtensionStateChanges(
   }
 }
 
-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 {
   // Omitted key => all enabled (pi default).
   if (filters === undefined) {
@@ -415,58 +411,37 @@ function getPackageFilterState(filters: string[] | undefined, extensionPath: str
   return enabled ? "enabled" : "disabled";
 }
 
-async function getPackageExtensionState(
-  packageSource: string,
-  extensionPath: string,
+async function readPackageFilterMap(
   scope: Scope,
   cwd: string
-): Promise<State> {
-  const settingsPath = getSettingsPath(scope, cwd);
-  const settings = await readSettingsFile(settingsPath);
+): Promise<Map<string, string[] | undefined>> {
+  const settings = await readSettingsFile(getSettingsPath(scope, cwd));
   const packages = settings.packages ?? [];
-  const normalizedSource = normalizeSource(packageSource);
+  const filterMap = new Map<string, string[] | undefined>();
 
-  const entry = packages.find((pkg) => {
-    if (typeof pkg === "string") {
-      return normalizeSource(pkg) === normalizedSource;
+  for (const entry of packages) {
+    if (typeof entry === "string") {
+      filterMap.set(normalizeSource(entry), undefined);
+      continue;
     }
-    return normalizeSource(pkg.source) === normalizedSource;
-  });
 
-  if (!entry || typeof entry === "string") {
-    return "enabled";
+    if (typeof entry.source !== "string") {
+      continue;
+    }
+
+    filterMap.set(
+      normalizeSource(entry.source),
+      Array.isArray(entry.extensions) ? entry.extensions : undefined
+    );
   }
 
-  return getPackageFilterState(entry.extensions, extensionPath);
+  return filterMap;
 }
 
 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
@@ -505,38 +480,12 @@ 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));
+  return resolveRelativePathSelection(
+    allFiles,
+    entries,
+    (path, files) => isExtensionEntrypointPath(path) && files.includes(path)
+  );
 }
 
 export async function readPackageManifest(
@@ -617,11 +566,19 @@ export async function discoverPackageExtensions(
   cwd: string
 ): Promise<PackageExtensionEntry[]> {
   const entries: PackageExtensionEntry[] = [];
+  const [globalFilterMap, projectFilterMap] = await Promise.all([
+    readPackageFilterMap("global", cwd),
+    readPackageFilterMap("project", cwd),
+  ]);
 
   for (const pkg of packages) {
     const packageRoot = await toPackageRoot(pkg, cwd);
     if (!packageRoot) continue;
 
+    const packageFilters =
+      (pkg.scope === "global" ? globalFilterMap : projectFilterMap).get(
+        normalizeSource(pkg.source)
+      ) ?? undefined;
     const extensionPaths = await discoverPackageExtensionEntrypoints(packageRoot);
     for (const extensionPath of extensionPaths) {
       const normalizedPath = normalizeRelativePath(extensionPath);
@@ -629,7 +586,7 @@ export async function discoverPackageExtensions(
       const summary = (await fileExists(absolutePath))
         ? await readSummary(absolutePath)
         : "package extension";
-      const state = await getPackageExtensionState(pkg.source, normalizedPath, pkg.scope, cwd);
+      const state = getPackageFilterState(packageFilters, normalizedPath);
 
       entries.push({
         id: `pkg-ext:${pkg.scope}:${pkg.source}:${normalizedPath}`,