pi-extmgr 0.1.26 → 0.1.28

package/src/packages/discovery.ts

@@ -3,23 +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 {
-  getPackageSourceKind,
-  normalizePackageIdentity,
-  splitGitRepoAndRef,
-  stripGitSourcePrefix,
-} from "../utils/package-source.js";
-import { execNpm } from "../utils/npm-exec.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";
 
 const NPM_SEARCH_API = "https://registry.npmjs.org/-/v1/search";
 const NPM_SEARCH_PAGE_SIZE = 250;
@@ -41,6 +38,18 @@ interface NpmSearchResponse {
 
 let searchCache: SearchCache | null = null;
 
+function createAbortError(): Error {
+  const error = new Error("Operation cancelled");
+  error.name = "AbortError";
+  return error;
+}
+
+function throwIfAborted(signal?: AbortSignal): void {
+  if (signal?.aborted) {
+    throw createAbortError();
+  }
+}
+
 export function getSearchCache(): SearchCache | null {
   return searchCache;
 }
@@ -61,13 +70,13 @@ 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 toNpmPackage(entry: NpmSearchResultObject): NpmPackage | undefined {
@@ -88,7 +97,8 @@ function toNpmPackage(entry: NpmSearchResultObject): NpmPackage | undefined {
 
 async function fetchNpmSearchPage(
   query: string,
-  from: number
+  from: number,
+  signal?: AbortSignal
 ): Promise<{
   total: number;
   resultCount: number;
@@ -101,7 +111,8 @@ async function fetchNpmSearchPage(
   });
   const response = await fetchWithTimeout(
     `${NPM_SEARCH_API}?${params.toString()}`,
-    TIMEOUTS.npmSearch
+    TIMEOUTS.npmSearch,
+    signal
   );
 
   if (!response.ok) {
@@ -120,13 +131,16 @@ async function fetchNpmSearchPage(
   };
 }
 
-export async function fetchNpmRegistrySearchResults(query: string): Promise<NpmPackage[]> {
+export async function fetchNpmRegistrySearchResults(
+  query: string,
+  signal?: AbortSignal
+): Promise<NpmPackage[]> {
   const packagesByName = new Map<string, NpmPackage>();
   let from = 0;
   let total = Infinity;
 
   while (from < total) {
-    const page = await fetchNpmSearchPage(query, from);
+    const page = await fetchNpmSearchPage(query, from, signal);
     total = page.total;
 
     if (page.resultCount === 0) {
@@ -148,11 +162,10 @@ export async function fetchNpmRegistrySearchResults(query: string): Promise<NpmP
 export async function searchNpmPackages(
   query: string,
   ctx: ExtensionCommandContext,
-  _pi: ExtensionAPI
+  options?: { signal?: AbortSignal }
 ): Promise<NpmPackage[]> {
-  // Check persistent cache first
   const cached = await getCachedSearch(query);
-  if (cached && cached.length > 0) {
+  if (cached) {
     if (ctx.hasUI) {
       ctx.ui.notify(`Using ${cached.length} cached results`, "info");
     }
@@ -163,7 +176,7 @@ export async function searchNpmPackages(
     ctx.ui.notify(`Searching npm for "${query}"...`, "info");
   }
 
-  const packages = await fetchNpmRegistrySearchResults(query);
+  const packages = await fetchNpmRegistrySearchResults(query, options?.signal);
 
   // Cache the results
   await setCachedSearch(query, packages);
@@ -174,256 +187,50 @@ export async function searchNpmPackages(
 export async function getInstalledPackages(
   ctx: ExtensionCommandContext | ExtensionContext,
   pi: ExtensionAPI,
-  onProgress?: (current: number, total: number) => void
+  onProgress?: (current: number, total: number) => void,
+  signal?: AbortSignal
 ): Promise<InstalledPackage[]> {
-  const res = await pi.exec("pi", ["list"], { timeout: TIMEOUTS.listPackages, cwd: ctx.cwd });
-  if (res.code !== 0) return [];
+  throwIfAborted(signal);
 
-  const text = res.stdout || "";
-  if (!text.trim() || /No packages installed/i.test(text)) {
+  const packages = await getPackageCatalog(ctx.cwd).listInstalledPackages();
+  if (packages.length === 0) {
     return [];
   }
 
-  const packages = parseInstalledPackagesOutput(text);
-
-  // Fetch metadata (descriptions and sizes) for packages in parallel
-  await addPackageMetadata(packages, ctx, pi, onProgress);
-
+  await addPackageMetadata(packages, ctx, pi, onProgress, signal);
+  throwIfAborted(signal);
   return packages;
 }
 
-function sanitizeListSourceSuffix(source: string): string {
-  return source
-    .trim()
-    .replace(/\s+\((filtered|pinned)\)$/i, "")
-    .trim();
-}
-
-function getInstalledPackageIdentity(pkg: InstalledPackage): string {
-  return normalizePackageIdentity(
-    pkg.source,
-    pkg.resolvedPath ? { resolvedPath: pkg.resolvedPath } : undefined
-  );
-}
-
-function isScopeHeader(lowerTrimmed: string, scope: "global" | "project"): boolean {
-  if (scope === "global") {
-    return (
-      lowerTrimmed === "global" ||
-      lowerTrimmed === "user" ||
-      lowerTrimmed.startsWith("global packages") ||
-      lowerTrimmed.startsWith("global:") ||
-      lowerTrimmed.startsWith("user packages") ||
-      lowerTrimmed.startsWith("user:")
-    );
-  }
-
-  return (
-    lowerTrimmed === "project" ||
-    lowerTrimmed === "local" ||
-    lowerTrimmed.startsWith("project packages") ||
-    lowerTrimmed.startsWith("project:") ||
-    lowerTrimmed.startsWith("local packages") ||
-    lowerTrimmed.startsWith("local:")
-  );
-}
-
-function looksLikePackageSource(source: string): boolean {
-  return getPackageSourceKind(source) !== "unknown";
-}
-
-function parseResolvedPathLine(line: string): string | undefined {
-  const resolvedMatch = line.match(/^resolved\s*:\s*(.+)$/i);
-  if (resolvedMatch?.[1]) {
-    return resolvedMatch[1].trim();
-  }
-
-  if (
-    line.startsWith("/") ||
-    line.startsWith("./") ||
-    line.startsWith("../") ||
-    line.startsWith(".\\") ||
-    line.startsWith("..\\") ||
-    line.startsWith("~/") ||
-    line.startsWith("file://") ||
-    /^[a-zA-Z]:[\\/]/.test(line) ||
-    line.startsWith("\\\\")
-  ) {
-    return line;
-  }
-
-  return undefined;
-}
-
-function parseInstalledPackagesOutputInternal(text: string): InstalledPackage[] {
-  const packages: InstalledPackage[] = [];
-
-  const lines = text.split("\n");
-  let currentScope: "global" | "project" = "global";
-  let currentPackage: InstalledPackage | undefined;
-
-  for (const rawLine of lines) {
-    if (!rawLine.trim()) continue;
-
-    const isIndented = /^(?:\t+|\s{4,})/.test(rawLine);
-    const trimmed = rawLine.trim();
-
-    if (isIndented && currentPackage) {
-      const resolved = parseResolvedPathLine(trimmed);
-      if (resolved) {
-        currentPackage.resolvedPath = resolved;
-      }
-      continue;
-    }
-
-    const lowerTrimmed = trimmed.toLowerCase();
-    if (isScopeHeader(lowerTrimmed, "global")) {
-      currentScope = "global";
-      currentPackage = undefined;
-      continue;
-    }
-    if (isScopeHeader(lowerTrimmed, "project")) {
-      currentScope = "project";
-      currentPackage = undefined;
-      continue;
-    }
-
-    const candidate = trimmed.replace(/^[-•]?\s*/, "").trim();
-    if (!looksLikePackageSource(candidate)) continue;
-
-    const source = sanitizeListSourceSuffix(candidate);
-    const { name, version } = parsePackageNameAndVersion(source);
+function getInstalledPackageIdentity(pkg: InstalledPackage, options?: { cwd?: string }): string {
+  const baseCwd = pkg.scope === "project" ? options?.cwd : getAgentDir();
 
-    const pkg: InstalledPackage = { source, name, scope: currentScope };
-    if (version !== undefined) {
-      pkg.version = version;
-    }
-    packages.push(pkg);
-    currentPackage = pkg;
-  }
-
-  return packages;
-}
-
-function shouldReplaceInstalledPackage(
-  current: InstalledPackage | undefined,
-  candidate: InstalledPackage
-): boolean {
-  if (!current) {
-    return true;
-  }
-
-  if (current.scope !== candidate.scope) {
-    return candidate.scope === "project";
-  }
-
-  return false;
-}
-
-export function parseInstalledPackagesOutput(text: string): InstalledPackage[] {
-  const parsed = parseInstalledPackagesOutputInternal(text);
-  const deduped = new Map<string, InstalledPackage>();
-
-  for (const pkg of parsed) {
-    const identity = getInstalledPackageIdentity(pkg);
-    const current = deduped.get(identity);
-    if (shouldReplaceInstalledPackage(current, pkg)) {
-      deduped.set(identity, pkg);
-    }
-  }
-
-  return Array.from(deduped.values());
+  return normalizePackageIdentity(pkg.source, {
+    ...(pkg.resolvedPath ? { resolvedPath: pkg.resolvedPath } : {}),
+    ...(baseCwd ? { cwd: baseCwd } : {}),
+  });
 }
 
-/**
- * Check whether a specific package source is installed.
- * Matches on normalized package source and optional scope.
- */
 export async function isSourceInstalled(
   source: string,
   ctx: ExtensionCommandContext | ExtensionContext,
-  pi: ExtensionAPI,
   options?: { scope?: "global" | "project" }
 ): Promise<boolean> {
-  try {
-    const res = await pi.exec("pi", ["list"], { timeout: TIMEOUTS.listPackages, cwd: ctx.cwd });
-    if (res.code !== 0) return false;
+  const installed = await getPackageCatalog(ctx.cwd).listInstalledPackages({ dedupe: false });
+  const expected = normalizePackageIdentity(source, { cwd: ctx.cwd });
 
-    const installed = parseInstalledPackagesOutputAllScopes(res.stdout || "");
-    const expected = normalizePackageIdentity(source);
-
-    return installed.some((pkg) => {
-      if (getInstalledPackageIdentity(pkg) !== expected) {
-        return false;
-      }
-      return options?.scope ? pkg.scope === options.scope : true;
-    });
-  } catch {
-    return false;
-  }
-}
-
-/**
- * parseInstalledPackagesOutputAllScopes returns the raw parsed entries from
- * parseInstalledPackagesOutputInternal without deduplication or scope merging.
- * Prefer parseInstalledPackagesOutput for user-facing lists, since it applies
- * deduplication and normalized scope selection.
- */
-export function parseInstalledPackagesOutputAllScopes(text: string): InstalledPackage[] {
-  return parseInstalledPackagesOutputInternal(text);
-}
-
-function extractGitPackageName(repoSpec: string): string {
-  // git@github.com:user/repo(.git)
-  if (repoSpec.startsWith("git@")) {
-    const afterColon = repoSpec.split(":").slice(1).join(":");
-    if (afterColon) {
-      const last = afterColon.split("/").pop() || afterColon;
-      return last.replace(/\.git$/i, "") || repoSpec;
+  return installed.some((pkg) => {
+    if (getInstalledPackageIdentity(pkg, { cwd: ctx.cwd }) !== expected) {
+      return false;
     }
-  }
-
-  // https://..., ssh://..., git://...
-  try {
-    const url = new URL(repoSpec);
-    const last = url.pathname.split("/").filter(Boolean).pop();
-    if (last) {
-      return last.replace(/\.git$/i, "") || repoSpec;
-    }
-  } catch {
-    // Fallback below
-  }
-
-  const last = repoSpec.split(/[/:]/).filter(Boolean).pop();
-  return (last ? last.replace(/\.git$/i, "") : repoSpec) || repoSpec;
+    return options?.scope ? pkg.scope === options.scope : true;
+  });
 }
 
-function parsePackageNameAndVersion(fullSource: string): {
-  name: string;
-  version?: string | undefined;
-} {
-  const parsedNpm = parseNpmSource(fullSource);
-  if (parsedNpm) {
-    return parsedNpm;
-  }
-
-  const sourceKind = getPackageSourceKind(fullSource);
-  if (sourceKind === "git") {
-    const gitSpec = stripGitSourcePrefix(fullSource);
-    const { repo } = splitGitRepoAndRef(gitSpec);
-    return { name: extractGitPackageName(repo) };
-  }
-
-  if (fullSource.includes("node_modules/")) {
-    const nmMatch = fullSource.match(/node_modules\/(.+)$/);
-    if (nmMatch?.[1]) {
-      return { name: nmMatch[1] };
-    }
-  }
-
-  const pathParts = fullSource.split(/[\\/]/);
-  const fileName = pathParts[pathParts.length - 1];
-  return { name: fileName || fullSource };
+export async function getInstalledPackagesAllScopes(
+  ctx: ExtensionCommandContext | ExtensionContext
+): Promise<InstalledPackage[]> {
+  return getPackageCatalog(ctx.cwd).listInstalledPackages({ dedupe: false });
 }
 
 async function hydratePackageFromResolvedPath(pkg: InstalledPackage): Promise<void> {
@@ -471,7 +278,8 @@ async function hydratePackageFromResolvedPath(pkg: InstalledPackage): Promise<vo
 async function fetchPackageSize(
   pkgName: string,
   ctx: ExtensionCommandContext | ExtensionContext,
-  pi: ExtensionAPI
+  pi: ExtensionAPI,
+  signal?: AbortSignal
 ): Promise<number | undefined> {
   // Check cache first
   const cachedSize = await getCachedPackageSize(pkgName);
@@ -481,6 +289,7 @@ async function fetchPackageSize(
     // Try to get unpacked size from npm view
     const res = await execNpm(pi, ["view", pkgName, "dist.unpackedSize", "--json"], ctx, {
       timeout: TIMEOUTS.npmView,
+      ...(signal ? { signal } : {}),
     });
     if (res.code === 0) {
       try {
@@ -503,25 +312,29 @@ async function addPackageMetadata(
   packages: InstalledPackage[],
   ctx: ExtensionCommandContext | ExtensionContext,
   pi: ExtensionAPI,
-  onProgress?: (current: number, total: number) => void
+  onProgress?: (current: number, total: number) => void,
+  signal?: AbortSignal
 ): Promise<void> {
-  // First, try to get descriptions from cache
+  throwIfAborted(signal);
+
   const cachedDescriptions = await getPackageDescriptions(packages);
   for (const [source, description] of cachedDescriptions) {
     const pkg = packages.find((p) => p.source === source);
     if (pkg) pkg.description = description;
   }
 
-  // Process remaining packages in batches
   const batchSize = 5;
   for (let i = 0; i < packages.length; i += batchSize) {
+    throwIfAborted(signal);
+
     const batch = packages.slice(i, i + batchSize);
 
-    // Report progress
     onProgress?.(i, packages.length);
 
     await Promise.all(
       batch.map(async (pkg) => {
+        throwIfAborted(signal);
+
         await hydratePackageFromResolvedPath(pkg);
 
         const needsDescription = !pkg.description;
@@ -546,6 +359,7 @@ async function addPackageMetadata(
                 } else {
                   const res = await execNpm(pi, ["view", pkgName, "description", "--json"], ctx, {
                     timeout: TIMEOUTS.npmView,
+                    ...(signal ? { signal } : {}),
                   });
                   if (res.code === 0) {
                     try {
@@ -565,7 +379,7 @@ async function addPackageMetadata(
               }
 
               if (needsSize) {
-                pkg.size = await fetchPackageSize(pkgName, ctx, pi);
+                pkg.size = await fetchPackageSize(pkgName, ctx, pi, signal);
               }
             }
           } else if (pkg.source.startsWith("git:")) {
@@ -578,8 +392,9 @@ async function addPackageMetadata(
         }
       })
     );
+
+    throwIfAborted(signal);
   }
 
-  // Final progress update
   onProgress?.(packages.length, packages.length);
 }

package/src/packages/extensions.ts

@@ -1,12 +1,17 @@
-import { mkdir, readFile, writeFile, rename, rm, readdir } from "node:fs/promises";
-import type { Dirent } from "node:fs";
+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 { 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 {
+  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 { resolveNpmCommand } from "../utils/npm-exec.js";

package/src/packages/install.ts

@@ -1,25 +1,30 @@
 /**
  * Package installation logic
  */
-import { mkdir, rm, writeFile, cp } from "node:fs/promises";
-import { join } from "node:path";
+import { cp, mkdir, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { join } from "node:path";
+import {
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  type ProgressEvent,
+} from "@mariozechner/pi-coding-agent";
+import { TIMEOUTS } from "../constants.js";
+import { runTaskWithLoader } from "../ui/async-task.js";
 import { normalizePackageSource } from "../utils/format.js";
 import { fileExists } from "../utils/fs.js";
-import { clearSearchCache, isSourceInstalled } from "./discovery.js";
-import { discoverPackageExtensionEntrypoints, readPackageManifest } from "./extensions.js";
-import { waitForCondition } from "../utils/retry.js";
 import { logPackageInstall } from "../utils/history.js";
-import { clearUpdatesAvailable } from "../utils/settings.js";
-import { notify, error as notifyError, success } from "../utils/notify.js";
-import { confirmAction, confirmReload, showProgress } from "../utils/ui-helpers.js";
 import { tryOperation } from "../utils/mode.js";
-import { updateExtmgrStatus } from "../utils/status.js";
+import { fetchWithTimeout } from "../utils/network.js";
+import { notify, error as notifyError, success } from "../utils/notify.js";
 import { execNpm } from "../utils/npm-exec.js";
 import { normalizePackageIdentity } from "../utils/package-source.js";
-import { fetchWithTimeout } from "../utils/network.js";
-import { TIMEOUTS } from "../constants.js";
+import { clearUpdatesAvailable } from "../utils/settings.js";
+import { updateExtmgrStatus } from "../utils/status.js";
+import { confirmAction, confirmReload, showProgress } from "../utils/ui-helpers.js";
+import { getPackageCatalog } from "./catalog.js";
+import { clearSearchCache } from "./discovery.js";
+import { discoverPackageExtensionEntrypoints, readPackageManifest } from "./extensions.js";
 
 export type InstallScope = "global" | "project";
 
@@ -27,6 +32,10 @@ export interface InstallOptions {
   scope?: InstallScope;
 }
 
+function getProgressMessage(event: ProgressEvent, fallback: string): string {
+  return event.message?.trim() || fallback;
+}
+
 async function resolveInstallScope(
   ctx: ExtensionCommandContext,
   explicitScope?: InstallScope
@@ -162,7 +171,7 @@ export async function installPackage(
 
   // Check if it's a GitHub URL to a .ts file - handle as direct download
   const githubTsMatch = source.match(
-    /^https:\/\/github\.com\/([^\/]+)\/([^\/]+)\/blob\/([^\/]+)\/(.+\.ts)$/
+    /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+\.ts)$/
   );
   const githubInfo = safeExtractGithubMatch(githubTsMatch);
   if (githubInfo) {
@@ -195,11 +204,25 @@ export async function installPackage(
 
   showProgress(ctx, "Installing", normalized);
 
-  const args = ["install", ...(scope === "project" ? ["-l"] : []), normalized];
-  const res = await pi.exec("pi", args, { timeout: TIMEOUTS.packageInstall, cwd: ctx.cwd });
-
-  if (res.code !== 0) {
-    const errorMsg = `Install failed:\n${res.stderr || res.stdout || `exit ${res.code}`}`;
+  try {
+    await runTaskWithLoader(
+      ctx,
+      {
+        title: "Install Package",
+        message: `Installing ${normalized}...`,
+        cancellable: false,
+        fallbackWithoutLoader: true,
+      },
+      async ({ setMessage }) => {
+        await getPackageCatalog(ctx.cwd).install(normalized, scope, (event) => {
+          setMessage(getProgressMessage(event, `Installing ${normalized}...`));
+        });
+        return undefined;
+      }
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const errorMsg = `Install failed:\n${message}`;
     logPackageInstall(pi, normalized, normalized, undefined, scope, false, errorMsg);
     notifyError(ctx, errorMsg);
     void updateExtmgrStatus(ctx, pi);
@@ -209,25 +232,7 @@ export async function installPackage(
   clearSearchCache();
   logPackageInstall(pi, normalized, normalized, undefined, scope, true);
   success(ctx, `Installed ${normalized} (${scope})`);
-  clearUpdatesAvailable(pi, ctx, [normalizePackageIdentity(normalized)]);
-
-  // Wait for the extension to be discoverable before reloading.
-  // This prevents a race condition where ctx.reload() runs before
-  // settings.json or extension files are fully flushed to disk.
-  notify(ctx, "Waiting for extension to be ready...", "info");
-  const isReady = await waitForCondition(() => isSourceInstalled(normalized, ctx, pi, { scope }), {
-    maxAttempts: 10,
-    delayMs: 100,
-    backoff: "exponential",
-  });
-
-  if (!isReady) {
-    notify(
-      ctx,
-      "Extension may not be immediately available. Reload pi manually if needed.",
-      "warning"
-    );
-  }
+  clearUpdatesAvailable(pi, ctx, [normalizePackageIdentity(normalized, { cwd: ctx.cwd })]);
 
   const reloaded = await confirmReload(ctx, "Package installed.");
   if (!reloaded) {