pi-extmgr 0.1.21 → 0.1.23

package/src/packages/management.ts

@@ -10,8 +10,12 @@ import {
   isSourceInstalled,
 } from "./discovery.js";
 import { waitForCondition } from "../utils/retry.js";
-import { formatInstalledPackageLabel, formatBytes, parseNpmSource } from "../utils/format.js";
-import { getPackageSourceKind, splitGitRepoAndRef } from "../utils/package-source.js";
+import { formatInstalledPackageLabel, parseNpmSource } from "../utils/format.js";
+import {
+  getPackageSourceKind,
+  normalizeLocalSourceIdentity,
+  splitGitRepoAndRef,
+} from "../utils/package-source.js";
 import { logPackageUpdate, logPackageRemove } from "../utils/history.js";
 import { clearUpdatesAvailable } from "../utils/settings.js";
 import { notify, error as notifyError, success } from "../utils/notify.js";
@@ -33,12 +37,19 @@ const NO_PACKAGE_MUTATION_OUTCOME: PackageMutationOutcome = {
   reloaded: false,
 };
 
+const BULK_UPDATE_LABEL = "all packages";
+
 function packageMutationOutcome(
   overrides: Partial<PackageMutationOutcome>
 ): PackageMutationOutcome {
   return { ...NO_PACKAGE_MUTATION_OUTCOME, ...overrides };
 }
 
+function isUpToDateOutput(stdout: string): boolean {
+  const pinnedAsStatus = /^\s*pinned\b(?!\s+dependency\b)(?:\s*$|\s*[:(-])/im.test(stdout);
+  return /already\s+up\s+to\s+date/i.test(stdout) || pinnedAsStatus;
+}
+
 async function updatePackageInternal(
   source: string,
   ctx: ExtensionCommandContext,
@@ -60,9 +71,10 @@ async function updatePackageInternal(
   }
 
   const stdout = res.stdout || "";
-  if (stdout.includes("already up to date") || stdout.includes("pinned")) {
+  if (isUpToDateOutput(stdout)) {
     notify(ctx, `${source} is already up to date (or pinned).`, "info");
     logPackageUpdate(pi, source, source, undefined, true);
+    clearUpdatesAvailable(pi, ctx);
     void updateExtmgrStatus(ctx, pi);
     return NO_PACKAGE_MUTATION_OUTCOME;
   }
@@ -87,18 +99,23 @@ async function updatePackagesInternal(
   const res = await pi.exec("pi", ["update"], { timeout: TIMEOUTS.packageUpdateAll, cwd: ctx.cwd });
 
   if (res.code !== 0) {
-    notifyError(ctx, `Update failed: ${res.stderr || res.stdout || `exit ${res.code}`}`);
+    const errorMsg = `Update failed: ${res.stderr || res.stdout || `exit ${res.code}`}`;
+    logPackageUpdate(pi, BULK_UPDATE_LABEL, BULK_UPDATE_LABEL, undefined, false, errorMsg);
+    notifyError(ctx, errorMsg);
     void updateExtmgrStatus(ctx, pi);
     return NO_PACKAGE_MUTATION_OUTCOME;
   }
 
   const stdout = res.stdout || "";
-  if (stdout.includes("already up to date") || stdout.trim() === "") {
+  if (isUpToDateOutput(stdout) || stdout.trim() === "") {
     notify(ctx, "All packages are already up to date.", "info");
+    logPackageUpdate(pi, BULK_UPDATE_LABEL, BULK_UPDATE_LABEL, undefined, true);
+    clearUpdatesAvailable(pi, ctx);
     void updateExtmgrStatus(ctx, pi);
     return NO_PACKAGE_MUTATION_OUTCOME;
   }
 
+  logPackageUpdate(pi, BULK_UPDATE_LABEL, BULK_UPDATE_LABEL, undefined, true);
   success(ctx, "Packages updated");
   clearUpdatesAvailable(pi, ctx);
 
@@ -145,12 +162,18 @@ function packageIdentity(source: string, fallbackName?: string): string {
     return `npm:${npm.name}`;
   }
 
-  if (getPackageSourceKind(source) === "git") {
+  const sourceKind = getPackageSourceKind(source);
+
+  if (sourceKind === "git") {
     const gitSpec = source.startsWith("git:") ? source.slice(4) : source;
     const { repo } = splitGitRepoAndRef(gitSpec);
     return `git:${repo}`;
   }
 
+  if (sourceKind === "local") {
+    return `src:${normalizeLocalSourceIdentity(source)}`;
+  }
+
   if (fallbackName) {
     return `name:${fallbackName}`;
   }
@@ -238,12 +261,18 @@ function formatRemovalTargets(targets: RemovalTarget[]): string {
   return targets.map((t) => `${t.scope}: ${t.source}`).join("\n");
 }
 
+interface RemovalExecutionResult {
+  target: RemovalTarget;
+  success: boolean;
+  error?: string;
+}
+
 async function executeRemovalTargets(
   targets: RemovalTarget[],
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI
-): Promise<string[]> {
-  const failures: string[] = [];
+): Promise<RemovalExecutionResult[]> {
+  const results: RemovalExecutionResult[] = [];
 
   for (const target of targets) {
     showProgress(ctx, "Removing", `${target.source} (${target.scope})`);
@@ -254,14 +283,15 @@ async function executeRemovalTargets(
     if (res.code !== 0) {
       const errorMsg = `Remove failed (${target.scope}): ${res.stderr || res.stdout || `exit ${res.code}`}`;
       logPackageRemove(pi, target.source, target.name, false, errorMsg);
-      failures.push(errorMsg);
+      results.push({ target, success: false, error: errorMsg });
       continue;
     }
 
     logPackageRemove(pi, target.source, target.name, true);
+    results.push({ target, success: true });
   }
 
-  return failures;
+  return results;
 }
 
 function notifyRemovalSummary(
@@ -326,9 +356,18 @@ async function removePackageInternal(
     return NO_PACKAGE_MUTATION_OUTCOME;
   }
 
-  const failures = await executeRemovalTargets(targets, ctx, pi);
+  const results = await executeRemovalTargets(targets, ctx, pi);
   clearSearchCache();
 
+  const failures = results
+    .filter((result): result is RemovalExecutionResult & { success: false; error: string } =>
+      Boolean(!result.success && result.error)
+    )
+    .map((result) => result.error);
+  const successfulTargets = results
+    .filter((result) => result.success)
+    .map((result) => result.target);
+
   const remaining = (await getInstalledPackagesAllScopes(ctx, pi)).filter(
     (p) => packageIdentity(p.source, p.name) === identity
   );
@@ -338,13 +377,15 @@ async function removePackageInternal(
     clearUpdatesAvailable(pi, ctx);
   }
 
-  // Wait for selected targets to disappear from their target scopes before reloading.
-  if (failures.length === 0 && targets.length > 0) {
+  const successfulRemovalCount = successfulTargets.length;
+
+  // Wait for successfully removed targets to disappear from their target scopes before reloading.
+  if (successfulTargets.length > 0) {
     notify(ctx, "Waiting for removal to complete...", "info");
     const isRemoved = await waitForCondition(
       async () => {
         const installedChecks = await Promise.all(
-          targets.map((target) =>
+          successfulTargets.map((target) =>
             isSourceInstalled(target.source, ctx, pi, {
               scope: target.scope,
             })
@@ -360,6 +401,11 @@ async function removePackageInternal(
     }
   }
 
+  if (successfulRemovalCount === 0) {
+    void updateExtmgrStatus(ctx, pi);
+    return NO_PACKAGE_MUTATION_OUTCOME;
+  }
+
   const reloaded = await confirmReload(ctx, "Removal complete.");
   if (!reloaded) {
     void updateExtmgrStatus(ctx, pi);
@@ -408,62 +454,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",

package/src/ui/package-config.ts

@@ -0,0 +1,361 @@
+/**
+ * Package extension configuration panel.
+ */
+import type { ExtensionAPI, ExtensionCommandContext, Theme } from "@mariozechner/pi-coding-agent";
+import { DynamicBorder, getSettingsListTheme } from "@mariozechner/pi-coding-agent";
+import {
+  Container,
+  Key,
+  matchesKey,
+  SettingsList,
+  Spacer,
+  Text,
+  type SettingItem,
+} from "@mariozechner/pi-tui";
+import type { InstalledPackage, PackageExtensionEntry, State } from "../types/index.js";
+import { discoverPackageExtensions, setPackageExtensionState } from "../packages/extensions.js";
+import { notify } from "../utils/notify.js";
+import { logExtensionToggle } from "../utils/history.js";
+import { getPackageSourceKind } from "../utils/package-source.js";
+import { fileExists } from "../utils/fs.js";
+import { UI } from "../constants.js";
+import { getChangeMarker, getPackageIcon, getScopeIcon, getStatusIcon } from "./theme.js";
+
+interface SelectableList {
+  selectedIndex?: number;
+  handleInput?(data: string): void;
+}
+
+export interface PackageConfigRow {
+  id: string;
+  extensionPath: string;
+  summary: string;
+  originalState: State;
+  available: boolean;
+}
+
+type ConfigurePanelAction = { type: "cancel" } | { type: "save" };
+
+function getSelectedIndex(settingsList: unknown): number | undefined {
+  if (settingsList && typeof settingsList === "object") {
+    const selectable = settingsList as SelectableList;
+    if (typeof selectable.selectedIndex === "number") {
+      return selectable.selectedIndex;
+    }
+  }
+  return undefined;
+}
+
+export async function buildPackageConfigRows(
+  entries: PackageExtensionEntry[]
+): Promise<PackageConfigRow[]> {
+  const dedupedEntries = new Map<string, PackageExtensionEntry>();
+  for (const entry of entries) {
+    if (!dedupedEntries.has(entry.extensionPath)) {
+      dedupedEntries.set(entry.extensionPath, entry);
+    }
+  }
+
+  const rows = await Promise.all(
+    Array.from(dedupedEntries.values()).map(async (entry) => ({
+      id: entry.id,
+      extensionPath: entry.extensionPath,
+      summary: entry.summary,
+      originalState: entry.state,
+      available: await fileExists(entry.absolutePath),
+    }))
+  );
+
+  rows.sort((a, b) => a.extensionPath.localeCompare(b.extensionPath));
+  return rows;
+}
+
+function formatConfigRowLabel(
+  row: PackageConfigRow,
+  state: State,
+  pkg: InstalledPackage,
+  theme: Theme,
+  changed: boolean
+): string {
+  const statusIcon = getStatusIcon(theme, state);
+  const scopeIcon = getScopeIcon(theme, pkg.scope);
+  const sourceKind = getPackageSourceKind(pkg.source);
+  const pkgIcon = getPackageIcon(
+    theme,
+    sourceKind === "npm" || sourceKind === "git" || sourceKind === "local" ? sourceKind : "local"
+  );
+  const changeMarker = getChangeMarker(theme, changed);
+  const name = theme.bold(row.extensionPath);
+  const availability = row.available
+    ? ""
+    : ` ${theme.fg("warning", "[missing]")}${theme.fg("dim", " (cannot toggle)")}`;
+  const summary = theme.fg("dim", row.summary);
+
+  return `${statusIcon} ${pkgIcon} [${scopeIcon}] ${name}${availability} - ${summary}${changeMarker}`;
+}
+
+function buildSettingItems(
+  rows: PackageConfigRow[],
+  staged: Map<string, State>,
+  pkg: InstalledPackage,
+  theme: Theme
+): SettingItem[] {
+  return rows.map((row) => {
+    const current = staged.get(row.id) ?? row.originalState;
+    const changed = current !== row.originalState;
+
+    return {
+      id: row.id,
+      label: formatConfigRowLabel(row, current, pkg, theme, changed),
+      currentValue: current,
+      values: row.available ? ["enabled", "disabled"] : [current],
+    };
+  });
+}
+
+function getPendingChangeCount(rows: PackageConfigRow[], staged: Map<string, State>): number {
+  let count = 0;
+
+  for (const row of rows) {
+    const target = staged.get(row.id);
+    if (!target) continue;
+    if (target !== row.originalState) count += 1;
+  }
+
+  return count;
+}
+
+async function showConfigurePanel(
+  pkg: InstalledPackage,
+  rows: PackageConfigRow[],
+  staged: Map<string, State>,
+  ctx: ExtensionCommandContext
+): Promise<ConfigurePanelAction> {
+  return ctx.ui.custom<ConfigurePanelAction>((tui, theme, _keybindings, done) => {
+    const container = new Container();
+
+    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+    container.addChild(
+      new Text(theme.fg("accent", theme.bold(`Configure extensions: ${pkg.name}`)), 2, 0)
+    );
+    container.addChild(
+      new Text(
+        theme.fg(
+          "muted",
+          `${rows.length} extension path${rows.length === 1 ? "" : "s"} • Space/Enter toggle • S save • Esc cancel`
+        ),
+        2,
+        0
+      )
+    );
+    container.addChild(new Spacer(1));
+
+    const settingsItems = buildSettingItems(rows, staged, pkg, theme);
+    const rowById = new Map(rows.map((row) => [row.id, row]));
+
+    const settingsList = new SettingsList(
+      settingsItems,
+      Math.min(rows.length + 2, UI.maxListHeight),
+      getSettingsListTheme(),
+      (id: string, newValue: string) => {
+        const row = rowById.get(id);
+        if (!row || !row.available) return;
+
+        const state = newValue as State;
+        staged.set(id, state);
+
+        const settingsItem = settingsItems.find((item) => item.id === id);
+        if (settingsItem) {
+          settingsItem.label = formatConfigRowLabel(
+            row,
+            state,
+            pkg,
+            theme,
+            state !== row.originalState
+          );
+        }
+
+        tui.requestRender();
+      },
+      () => done({ type: "cancel" }),
+      { enableSearch: rows.length > UI.searchThreshold }
+    );
+
+    container.addChild(settingsList);
+    container.addChild(new Spacer(1));
+    container.addChild(
+      new Text(theme.fg("dim", "↑↓ Navigate | Space/Enter Toggle | S Save | Esc Back"), 2, 0)
+    );
+    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+
+    return {
+      render(width: number) {
+        return container.render(width);
+      },
+      invalidate() {
+        container.invalidate();
+      },
+      handleInput(data: string) {
+        if (matchesKey(data, Key.ctrl("s")) || data === "s" || data === "S") {
+          done({ type: "save" });
+          return;
+        }
+
+        const selectedIndex = getSelectedIndex(settingsList) ?? 0;
+        const selectedId = settingsItems[selectedIndex]?.id ?? settingsItems[0]?.id;
+        const selectedRow = selectedId ? rowById.get(selectedId) : undefined;
+
+        if (
+          selectedRow &&
+          !selectedRow.available &&
+          (data === " " || data === "\r" || data === "\n")
+        ) {
+          notify(
+            ctx,
+            `${selectedRow.extensionPath} is missing on disk and cannot be toggled.`,
+            "warning"
+          );
+          return;
+        }
+
+        settingsList.handleInput?.(data);
+        tui.requestRender();
+      },
+    };
+  });
+}
+
+export async function applyPackageExtensionChanges(
+  rows: PackageConfigRow[],
+  staged: Map<string, State>,
+  pkg: InstalledPackage,
+  cwd: string,
+  pi: ExtensionAPI
+): Promise<{ changed: number; errors: string[] }> {
+  let changed = 0;
+  const errors: string[] = [];
+
+  const sortedRows = [...rows].sort((a, b) => a.extensionPath.localeCompare(b.extensionPath));
+
+  for (const row of sortedRows) {
+    const target = staged.get(row.id) ?? row.originalState;
+    if (target === row.originalState) continue;
+
+    if (!row.available) {
+      const error = `${row.extensionPath}: extension entrypoint is missing on disk`;
+      errors.push(error);
+      logExtensionToggle(pi, row.id, row.originalState, target, false, error);
+      continue;
+    }
+
+    const result = await setPackageExtensionState(
+      pkg.source,
+      row.extensionPath,
+      pkg.scope,
+      target,
+      cwd
+    );
+
+    if (result.ok) {
+      changed += 1;
+      logExtensionToggle(pi, row.id, row.originalState, target, true);
+    } else {
+      errors.push(`${row.extensionPath}: ${result.error}`);
+      logExtensionToggle(pi, row.id, row.originalState, target, false, result.error);
+    }
+  }
+
+  return { changed, errors };
+}
+
+async function promptRestartForPackageConfig(ctx: ExtensionCommandContext): Promise<boolean> {
+  if (!ctx.hasUI) {
+    notify(
+      ctx,
+      "Restart pi to apply package extension configuration changes. /reload may not be enough.",
+      "warning"
+    );
+    return false;
+  }
+
+  const restartNow = await ctx.ui.confirm(
+    "Restart Required",
+    "Package extension configuration changed.\nA full pi restart is required to apply it.\nExit pi now?"
+  );
+
+  if (!restartNow) {
+    notify(
+      ctx,
+      "Restart pi manually to apply package extension configuration changes. /reload may not be enough.",
+      "warning"
+    );
+    return false;
+  }
+
+  notify(ctx, "Shutting down pi. Start it again to apply changes.", "info");
+  ctx.shutdown();
+  return true;
+}
+
+export async function configurePackageExtensions(
+  pkg: InstalledPackage,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI
+): Promise<{ changed: number; reloaded: boolean }> {
+  const discovered = await discoverPackageExtensions([pkg], ctx.cwd);
+  const rows = await buildPackageConfigRows(discovered);
+
+  if (rows.length === 0) {
+    notify(ctx, "No configurable extensions discovered for this package.", "info");
+    return { changed: 0, reloaded: false };
+  }
+
+  const staged = new Map<string, State>();
+
+  while (true) {
+    const action = await showConfigurePanel(pkg, rows, staged, ctx);
+
+    if (action.type === "cancel") {
+      const pending = getPendingChangeCount(rows, staged);
+      if (pending === 0) {
+        return { changed: 0, reloaded: false };
+      }
+
+      const choice = await ctx.ui.select(`Unsaved changes (${pending})`, [
+        "Save and back",
+        "Discard changes",
+        "Stay in configure",
+      ]);
+
+      if (!choice || choice === "Stay in configure") {
+        continue;
+      }
+
+      if (choice === "Discard changes") {
+        return { changed: 0, reloaded: false };
+      }
+    }
+
+    const apply = await applyPackageExtensionChanges(rows, staged, pkg, ctx.cwd, pi);
+
+    if (apply.errors.length > 0) {
+      notify(
+        ctx,
+        `Applied ${apply.changed} change(s), ${apply.errors.length} failed.\n${apply.errors.join("\n")}`,
+        "warning"
+      );
+    } else if (apply.changed === 0) {
+      notify(ctx, "No changes to apply.", "info");
+      return { changed: 0, reloaded: false };
+    } else {
+      notify(ctx, `Applied ${apply.changed} package extension change(s).`, "info");
+    }
+
+    if (apply.changed === 0) {
+      return { changed: 0, reloaded: false };
+    }
+
+    const restarted = await promptRestartForPackageConfig(ctx);
+    return { changed: apply.changed, reloaded: restarted };
+  }
+}

package/src/ui/remote.ts

@@ -15,6 +15,7 @@ import {
   isCacheValid,
 } from "../packages/discovery.js";
 import { installPackage, installPackageLocally } from "../packages/install.js";
+import { execNpm } from "../utils/npm-exec.js";
 import { notify } from "../utils/notify.js";
 
 interface PackageInfoCacheEntry {
@@ -143,9 +144,8 @@ async function buildPackageInfoText(
   }
 
   const [infoRes, weeklyDownloads] = await Promise.all([
-    pi.exec("npm", ["view", packageName, "--json"], {
+    execNpm(pi, ["view", packageName, "--json"], ctx, {
       timeout: TIMEOUTS.npmView,
-      cwd: ctx.cwd,
     }),
     fetchWeeklyDownloads(packageName),
   ]);