pi-extmgr 0.1.28 → 0.2.1

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}`,

package/src/packages/install.ts

@@ -11,6 +11,7 @@ import {
 } from "@mariozechner/pi-coding-agent";
 import { TIMEOUTS } from "../constants.js";
 import { runTaskWithLoader } from "../ui/async-task.js";
+import { parseChoiceByLabel } from "../utils/command.js";
 import { normalizePackageSource } from "../utils/format.js";
 import { fileExists } from "../utils/fs.js";
 import { logPackageInstall } from "../utils/history.js";
@@ -32,6 +33,17 @@ export interface InstallOptions {
   scope?: InstallScope;
 }
 
+export interface InstallOutcome {
+  installed: boolean;
+  reloaded: boolean;
+}
+
+const INSTALL_SCOPE_CHOICES = {
+  global: "Global (~/.pi/agent/settings.json)",
+  project: "Project (.pi/settings.json)",
+  cancel: "Cancel",
+} as const;
+
 function getProgressMessage(event: ProgressEvent, fallback: string): string {
   return event.message?.trim() || fallback;
 }
@@ -44,14 +56,12 @@ async function resolveInstallScope(
 
   if (!ctx.hasUI) return "global";
 
-  const choice = await ctx.ui.select("Install scope", [
-    "Global (~/.pi/agent/settings.json)",
-    "Project (.pi/settings.json)",
-    "Cancel",
-  ]);
+  const choice = parseChoiceByLabel(
+    INSTALL_SCOPE_CHOICES,
+    await ctx.ui.select("Install scope", Object.values(INSTALL_SCOPE_CHOICES))
+  );
 
-  if (!choice || choice === "Cancel") return undefined;
-  return choice.startsWith("Project") ? "project" : "global";
+  return choice === "cancel" ? undefined : choice;
 }
 
 function getExtensionInstallDir(ctx: ExtensionCommandContext, scope: InstallScope): string {
@@ -61,28 +71,6 @@ function getExtensionInstallDir(ctx: ExtensionCommandContext, scope: InstallScop
   return join(homedir(), ".pi", "agent", "extensions");
 }
 
-interface GithubUrlInfo {
-  owner: string;
-  repo: string;
-  branch: string;
-  filePath: string;
-}
-
-/**
- * Safely extracts regex match groups with validation
- */
-function safeExtractGithubMatch(match: RegExpMatchArray | null): GithubUrlInfo | undefined {
-  if (!match) return undefined;
-
-  const [, owner, repo, branch, filePath] = match;
-
-  if (!owner || !repo || !branch || !filePath) {
-    return undefined;
-  }
-
-  return { owner, repo, branch, filePath };
-}
-
 async function ensureTarAvailable(
   pi: ExtensionAPI,
   ctx: ExtensionCommandContext
@@ -157,36 +145,35 @@ async function cleanupStandaloneTempArtifacts(tempDir: string, extractDir?: stri
   );
 }
 
-export async function installPackage(
+async function installPackageInternal(
   source: string,
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI,
   options?: InstallOptions
-): Promise<void> {
+): Promise<InstallOutcome> {
   const scope = await resolveInstallScope(ctx, options?.scope);
   if (!scope) {
     notify(ctx, "Installation cancelled.", "info");
-    return;
+    return { installed: false, reloaded: false };
   }
 
   // Check if it's a GitHub URL to a .ts file - handle as direct download
   const githubTsMatch = source.match(
     /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+\.ts)$/
   );
-  const githubInfo = safeExtractGithubMatch(githubTsMatch);
-  if (githubInfo) {
-    const rawUrl = `https://raw.githubusercontent.com/${githubInfo.owner}/${githubInfo.repo}/${githubInfo.branch}/${githubInfo.filePath}`;
-    const fileName =
-      githubInfo.filePath.split("/").pop() || `${githubInfo.owner}-${githubInfo.repo}.ts`;
-    await installFromUrl(rawUrl, fileName, ctx, pi, { scope });
-    return;
+  if (githubTsMatch) {
+    const [, owner, repo, branch, filePath] = githubTsMatch;
+    if (owner && repo && branch && filePath) {
+      const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${filePath}`;
+      const fileName = filePath.split("/").pop() || `${owner}-${repo}.ts`;
+      return await installFromUrl(rawUrl, fileName, ctx, pi, { scope });
+    }
   }
 
   // Check if it's already a raw URL to a .ts file
   if (source.match(/^https:\/\/raw\.githubusercontent\.com\/.*\.ts$/)) {
     const fileName = source.split("/").pop() || "extension.ts";
-    await installFromUrl(source, fileName, ctx, pi, { scope });
-    return;
+    return await installFromUrl(source, fileName, ctx, pi, { scope });
   }
 
   const normalized = normalizePackageSource(source);
@@ -199,7 +186,7 @@ export async function installPackage(
   );
   if (!confirmed) {
     notify(ctx, "Installation cancelled.", "info");
-    return;
+    return { installed: false, reloaded: false };
   }
 
   showProgress(ctx, "Installing", normalized);
@@ -226,7 +213,7 @@ export async function installPackage(
     logPackageInstall(pi, normalized, normalized, undefined, scope, false, errorMsg);
     notifyError(ctx, errorMsg);
     void updateExtmgrStatus(ctx, pi);
-    return;
+    return { installed: false, reloaded: false };
   }
 
   clearSearchCache();
@@ -238,6 +225,26 @@ export async function installPackage(
   if (!reloaded) {
     void updateExtmgrStatus(ctx, pi);
   }
+
+  return { installed: true, reloaded };
+}
+
+export async function installPackage(
+  source: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+  options?: InstallOptions
+): Promise<void> {
+  await installPackageInternal(source, ctx, pi, options);
+}
+
+export async function installPackageWithOutcome(
+  source: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+  options?: InstallOptions
+): Promise<InstallOutcome> {
+  return installPackageInternal(source, ctx, pi, options);
 }
 
 export async function installFromUrl(
@@ -246,11 +253,11 @@ export async function installFromUrl(
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI,
   options?: InstallOptions
-): Promise<void> {
+): Promise<InstallOutcome> {
   const scope = await resolveInstallScope(ctx, options?.scope);
   if (!scope) {
     notify(ctx, "Installation cancelled.", "info");
-    return;
+    return { installed: false, reloaded: false };
   }
 
   const extensionDir = getExtensionInstallDir(ctx, scope);
@@ -263,7 +270,7 @@ export async function installFromUrl(
   );
   if (!confirmed) {
     notify(ctx, "Installation cancelled.", "info");
-    return;
+    return { installed: false, reloaded: false };
   }
 
   const result = await tryOperation(
@@ -289,7 +296,7 @@ export async function installFromUrl(
   if (!result) {
     logPackageInstall(pi, url, fileName, undefined, scope, false, "Installation failed");
     void updateExtmgrStatus(ctx, pi);
-    return;
+    return { installed: false, reloaded: false };
   }
 
   const { fileName: name, destPath } = result;
@@ -300,6 +307,8 @@ export async function installFromUrl(
   if (!reloaded) {
     void updateExtmgrStatus(ctx, pi);
   }
+
+  return { installed: true, reloaded };
 }
 
 /**
@@ -324,16 +333,16 @@ function parsePackageInfo(viewOutput: string): { version: string; tarballUrl: st
   }
 }
 
-export async function installPackageLocally(
+async function installPackageLocallyInternal(
   packageName: string,
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI,
   options?: InstallOptions
-): Promise<void> {
+): Promise<InstallOutcome> {
   const scope = await resolveInstallScope(ctx, options?.scope);
   if (!scope) {
     notify(ctx, "Installation cancelled.", "info");
-    return;
+    return { installed: false, reloaded: false };
   }
 
   const extensionDir = getExtensionInstallDir(ctx, scope);
@@ -346,7 +355,7 @@ export async function installPackageLocally(
   );
   if (!confirmed) {
     notify(ctx, "Installation cancelled.", "info");
-    return;
+    return { installed: false, reloaded: false };
   }
 
   const result = await tryOperation(
@@ -384,7 +393,7 @@ export async function installPackageLocally(
       "Failed to fetch package info"
     );
     void updateExtmgrStatus(ctx, pi);
-    return;
+    return { installed: false, reloaded: false };
   }
   const { version, tarballUrl } = result;
 
@@ -401,7 +410,7 @@ export async function installPackageLocally(
       tarAvailability.error
     );
     void updateExtmgrStatus(ctx, pi);
-    return;
+    return { installed: false, reloaded: false };
   }
 
   // Download and extract
@@ -439,7 +448,7 @@ export async function installPackageLocally(
       "Download failed"
     );
     void updateExtmgrStatus(ctx, pi);
-    return;
+    return { installed: false, reloaded: false };
   }
   const { tarballPath } = extractResult;
 
@@ -496,7 +505,7 @@ export async function installPackageLocally(
       "Extraction failed"
     );
     void updateExtmgrStatus(ctx, pi);
-    return;
+    return { installed: false, reloaded: false };
   }
 
   // Copy to extensions dir
@@ -527,7 +536,7 @@ export async function installPackageLocally(
       "Failed to copy extension"
     );
     void updateExtmgrStatus(ctx, pi);
-    return;
+    return { installed: false, reloaded: false };
   }
 
   clearSearchCache();
@@ -538,4 +547,24 @@ export async function installPackageLocally(
   if (!reloaded) {
     void updateExtmgrStatus(ctx, pi);
   }
+
+  return { installed: true, reloaded };
+}
+
+export async function installPackageLocally(
+  packageName: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+  options?: InstallOptions
+): Promise<void> {
+  await installPackageLocallyInternal(packageName, ctx, pi, options);
+}
+
+export async function installPackageLocallyWithOutcome(
+  packageName: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+  options?: InstallOptions
+): Promise<InstallOutcome> {
+  return installPackageLocallyInternal(packageName, ctx, pi, options);
 }