pi-extmgr 0.1.26 → 0.1.28

package/src/utils/package-source.ts

@@ -1,6 +1,9 @@
 /**
  * Package source parsing helpers shared across discovery/management flows.
  */
+import { homedir } from "node:os";
+import { join, resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
 import { parseNpmSource } from "./format.js";
 
 export type PackageSourceKind = "npm" | "git" | "local" | "unknown";
@@ -61,9 +64,35 @@ export function stripGitSourcePrefix(source: string): string {
   return withoutGitPlus.startsWith("git:") ? withoutGitPlus.slice(4) : withoutGitPlus;
 }
 
+function resolveLocalSourceForIdentity(source: string, cwd?: string): string {
+  if (source.startsWith("file://")) {
+    try {
+      return fileURLToPath(source);
+    } catch {
+      return source;
+    }
+  }
+
+  if (source.startsWith("~/")) {
+    return join(homedir(), source.slice(2));
+  }
+
+  if (
+    cwd &&
+    (source.startsWith("./") ||
+      source.startsWith("../") ||
+      source.startsWith(".\\") ||
+      source.startsWith("..\\"))
+  ) {
+    return resolvePath(cwd, source);
+  }
+
+  return source;
+}
+
 export function normalizePackageIdentity(
   source: string,
-  options?: { resolvedPath?: string }
+  options?: { resolvedPath?: string; cwd?: string }
 ): string {
   const normalized = sanitizeSource(source);
   const kind = getPackageSourceKind(normalized);
@@ -80,7 +109,9 @@ export function normalizePackageIdentity(
   }
 
   if (kind === "local") {
-    return `local:${normalizeLocalSourceIdentity(options?.resolvedPath ?? normalized)}`;
+    const localSource =
+      options?.resolvedPath ?? resolveLocalSourceForIdentity(normalized, options?.cwd);
+    return `local:${normalizeLocalSourceIdentity(localSource)}`;
   }
 
   return `raw:${normalized.replace(/\\/g, "/").toLowerCase()}`;
@@ -100,3 +131,54 @@ export function splitGitRepoAndRef(gitSpec: string): { repo: string; ref?: strin
 
   return { repo: gitSpec.slice(0, lastAt), ref: tail };
 }
+
+function extractGitPackageName(repoSpec: string): string {
+  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;
+    }
+  }
+
+  try {
+    const url = new URL(repoSpec);
+    const last = url.pathname.split("/").filter(Boolean).pop();
+    if (last) {
+      return last.replace(/\.git$/i, "") || repoSpec;
+    }
+  } catch {
+    // Fall back to generic path splitting below.
+  }
+
+  const last = repoSpec.split(/[/:]/).filter(Boolean).pop();
+  return (last ? last.replace(/\.git$/i, "") : repoSpec) || repoSpec;
+}
+
+export 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 };
+}

package/src/utils/retry.ts

@@ -23,7 +23,7 @@ export async function retryWithBackoff<T>(
     if (attempt < maxAttempts) {
       const delay =
         backoff === "exponential"
-          ? delayMs * Math.pow(2, attempt - 1)
+          ? delayMs * 2 ** (attempt - 1)
           : backoff === "linear"
             ? delayMs * attempt
             : delayMs;

package/src/utils/settings.ts

@@ -2,14 +2,15 @@
  * Auto-update settings storage
  * Persists to disk so config survives across pi sessions.
  */
-import type {
-  ExtensionAPI,
-  ExtensionCommandContext,
-  ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
-import { readFile, writeFile, mkdir, rename, rm } from "node:fs/promises";
+
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import {
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  type ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
 import { fileExists } from "./fs.js";
 import { normalizePackageIdentity } from "./package-source.js";
 
@@ -328,8 +329,16 @@ export function parseDuration(input: string): { ms: number; display: string } |
     /^(\d+)\s*(h|hr|hrs|hour|hours|d|day|days|w|wk|wks|week|weeks|m|mo|mos|month|months)$/
   );
   if (durationMatch) {
-    const value = parseInt(durationMatch[1]!, 10);
-    const unit = durationMatch[2]![0]; // First character of unit
+    const [, rawValue, rawUnit] = durationMatch;
+    if (!rawValue || !rawUnit) {
+      return undefined;
+    }
+
+    const value = Number.parseInt(rawValue, 10);
+    const unit = rawUnit[0];
+    if (!unit) {
+      return undefined;
+    }
 
     let ms: number;
     let display: string;

package/src/utils/status.ts

@@ -1,26 +1,30 @@
 /**
  * Status bar helpers for extmgr
  */
-import type {
-  ExtensionAPI,
-  ExtensionCommandContext,
-  ExtensionContext,
+import {
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  type ExtensionContext,
+  getAgentDir,
 } from "@mariozechner/pi-coding-agent";
-import { getInstalledPackages } from "../packages/discovery.js";
+import { getPackageCatalog, type PackageCatalog } from "../packages/catalog.js";
 import { getAutoUpdateStatus } from "./auto-update.js";
 import { normalizePackageIdentity } from "./package-source.js";
 import { getAutoUpdateConfigAsync, saveAutoUpdateConfig } from "./settings.js";
 
+type CatalogInstalledPackages = Awaited<ReturnType<PackageCatalog["listInstalledPackages"]>>;
+
 function filterStaleUpdates(
   knownUpdates: string[],
-  installedPackages: Awaited<ReturnType<typeof getInstalledPackages>>
+  installedPackages: CatalogInstalledPackages,
+  cwd: string
 ): string[] {
   const installedIdentities = new Set(
     installedPackages.map((pkg) =>
-      normalizePackageIdentity(
-        pkg.source,
-        pkg.resolvedPath ? { resolvedPath: pkg.resolvedPath } : undefined
-      )
+      normalizePackageIdentity(pkg.source, {
+        ...(pkg.resolvedPath ? { resolvedPath: pkg.resolvedPath } : {}),
+        cwd: pkg.scope === "project" ? cwd : getAgentDir(),
+      })
     )
   );
   return knownUpdates.filter((identity) => installedIdentities.has(identity));
@@ -34,7 +38,7 @@ export async function updateExtmgrStatus(
 
   try {
     const [packages, autoUpdateConfig] = await Promise.all([
-      getInstalledPackages(ctx, pi),
+      getPackageCatalog(ctx.cwd).listInstalledPackages(),
       getAutoUpdateConfigAsync(ctx),
     ]);
     const statusParts: string[] = [];
@@ -50,7 +54,7 @@ export async function updateExtmgrStatus(
 
     // Validate updates against actually installed packages (handles external pi update)
     const knownUpdates = autoUpdateConfig.updatesAvailable ?? [];
-    const validUpdates = filterStaleUpdates(knownUpdates, packages);
+    const validUpdates = filterStaleUpdates(knownUpdates, packages, ctx.cwd);
 
     // If stale updates were filtered, persist the correction
     if (validUpdates.length !== knownUpdates.length) {

package/src/utils/ui-helpers.ts

@@ -1,9 +1,9 @@
 /**
  * Common UI helper patterns
  */
-import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
-import { notify } from "./notify.js";
+import { type ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
 import { UI } from "../constants.js";
+import { notify } from "./notify.js";
 
 /**
  * Confirm and trigger reload
@@ -21,7 +21,7 @@ export async function confirmReload(
   const confirmed = await ctx.ui.confirm("Reload Required", `${reason}\nReload pi now?`);
 
   if (confirmed) {
-    await (ctx as ExtensionCommandContext & { reload: () => Promise<void> }).reload();
+    await ctx.reload();
     return true;
   }