pi-extmgr 0.1.27 → 0.2.0

package/src/packages/discovery.ts

@@ -3,19 +3,20 @@
  */
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import type {
-  ExtensionAPI,
-  ExtensionCommandContext,
-  ExtensionContext,
+import {
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  type ExtensionContext,
+  getAgentDir,
 } from "@mariozechner/pi-coding-agent";
-import type { InstalledPackage, NpmPackage, SearchCache } from "../types/index.js";
 import { CACHE_TTL, TIMEOUTS } from "../constants.js";
-import { readSummary } from "../utils/fs.js";
+import { type InstalledPackage, type NpmPackage, type SearchCache } from "../types/index.js";
 import { parseNpmSource } from "../utils/format.js";
+import { readSummary } from "../utils/fs.js";
+import { fetchWithTimeout } from "../utils/network.js";
+import { execNpm } from "../utils/npm-exec.js";
 import { normalizePackageIdentity } from "../utils/package-source.js";
 import { getPackageCatalog } from "./catalog.js";
-import { execNpm } from "../utils/npm-exec.js";
-import { fetchWithTimeout } from "../utils/network.js";
 
 const NPM_SEARCH_API = "https://registry.npmjs.org/-/v1/search";
 const NPM_SEARCH_PAGE_SIZE = 250;
@@ -27,6 +28,14 @@ interface NpmSearchResultObject {
     description?: string;
     keywords?: string[];
     date?: string;
+    publisher?: {
+      username?: string;
+      email?: string;
+    };
+    maintainers?: Array<{
+      username?: string;
+      email?: string;
+    }>;
   };
 }
 
@@ -69,15 +78,40 @@ export function isCacheValid(query: string): boolean {
 
 // Import persistent cache
 import {
-  getCachedSearch,
-  setCachedSearch,
   getCachedPackage,
-  setCachedPackage,
-  getPackageDescriptions,
   getCachedPackageSize,
+  getCachedSearch,
+  getPackageDescriptions,
+  setCachedPackage,
   setCachedPackageSize,
+  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;
@@ -89,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,
   };
@@ -201,11 +236,13 @@ export async function getInstalledPackages(
   return packages;
 }
 
-function getInstalledPackageIdentity(pkg: InstalledPackage): string {
-  return normalizePackageIdentity(
-    pkg.source,
-    pkg.resolvedPath ? { resolvedPath: pkg.resolvedPath } : undefined
-  );
+function getInstalledPackageIdentity(pkg: InstalledPackage, options?: { cwd?: string }): string {
+  const baseCwd = pkg.scope === "project" ? options?.cwd : getAgentDir();
+
+  return normalizePackageIdentity(pkg.source, {
+    ...(pkg.resolvedPath ? { resolvedPath: pkg.resolvedPath } : {}),
+    ...(baseCwd ? { cwd: baseCwd } : {}),
+  });
 }
 
 export async function isSourceInstalled(
@@ -214,10 +251,10 @@ export async function isSourceInstalled(
   options?: { scope?: "global" | "project" }
 ): Promise<boolean> {
   const installed = await getPackageCatalog(ctx.cwd).listInstalledPackages({ dedupe: false });
-  const expected = normalizePackageIdentity(source);
+  const expected = normalizePackageIdentity(source, { cwd: ctx.cwd });
 
   return installed.some((pkg) => {
-    if (getInstalledPackageIdentity(pkg) !== expected) {
+    if (getInstalledPackageIdentity(pkg, { cwd: ctx.cwd }) !== expected) {
       return false;
     }
     return options?.scope ? pkg.scope === options.scope : true;

package/src/packages/extensions.ts

@@ -1,14 +1,24 @@
-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 { type Dirent } from "node:fs";
+import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+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";
-import type { InstalledPackage, PackageExtensionEntry, Scope, State } from "../types/index.js";
+import {
+  type InstalledPackage,
+  type PackageExtensionEntry,
+  type Scope,
+  type State,
+} 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 {
@@ -31,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()
@@ -233,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(
@@ -271,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;
@@ -317,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;
@@ -335,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) {
@@ -410,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
@@ -500,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(
@@ -612,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);
@@ -624,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}`,